{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "369c3444",
   "metadata": {},
   "source": [
    "# ReadtheDocs Retrieval Augmented Generation (RAG)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ffd11a",
   "metadata": {},
   "source": [
    "In this notebook, we are going to use Milvus documentation pages to create a chatbot about our product.  The chatbot is going to follow RAG steps to retrieve chunks of data using Semantic Vector Search, then the Question + Context will be fed as a Prompt to a LLM to generate an answer.\n",
    "\n",
    "Many RAG demos use OpenAI for the Embedding Model and ChatGPT for the Generative AI model.  **In this notebook, we will demo a fully open source RAG stack.**\n",
    "\n",
    "Using open-source Q&A with retrieval saves money since we make free calls to our own data almost all the time - retrieval, evaluation, and development iterations.\n",
    "\n",
    "<div>\n",
    "<img src=\"../../../images/rag_image.png\" width=\"80%\"/>\n",
    "</div>\n",
    "\n",
    "Let's get started!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b2509fe9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For colab install these libraries in this order:\n",
    "# !python -m pip install torch transformers sentence-transformers langchain\n",
    "# !python -m pip install -U pymilvus\n",
    "# !python -m pip install unstructured openai tqdm numpy ipykernel \n",
    "# !python -m pip install ragas datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d7570b2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import common libraries.\n",
    "import sys, os, time, pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0cac5a60",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to remove newlines and double spaces from a string.\n",
    "def clean_text(text):\n",
    "    clean_text = text.replace(\"\\n\\n\", \" \")\\\n",
    "                     .replace(\"\\n\", \" \")\\\n",
    "                     .replace(\"<br><br>\", \" \")\\\n",
    "                     .replace(\"<br /><br />\", \" \")\n",
    "    \n",
    "    # Remove extra whitespace.\n",
    "    clean_text = ' '.join(clean_text.split())\n",
    "    return clean_text\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Function to inspect chunk lengths in matplotlit.\n",
    "def plot_chunk_lengths(chunked_docs, title_keyword):\n",
    "    # Get chunk lengths.\n",
    "    lengths = [len(doc.page_content) for doc in chunked_docs]\n",
    "\n",
    "    # Mean, median lengths.\n",
    "    mean_length = np.mean(lengths)\n",
    "    median_length = np.median(lengths)\n",
    "\n",
    "    # Assemble the title.\n",
    "    title = f\"Chunk Lengths from {title_keyword} Chunking\"\n",
    "\n",
    "    # Plot the lengths.\n",
    "    plt.figure(figsize=(10, 6))  # Adjust figure size\n",
    "    plt.plot(lengths, marker='o')  # Plot lengths with circle markers\n",
    "    plt.title(title, fontsize=20, fontweight='bold')\n",
    "    plt.xlabel('Document Index')  # X-axis label\n",
    "    plt.ylabel('Length')  # Y-axis label\n",
    "    plt.grid(True)  # Show grid\n",
    "\n",
    "    # Add a horizontal line at mean and median length\n",
    "    plt.axhline(y=mean_length, color='g', linestyle='-')\n",
    "    plt.axhline(y=median_length, color='r', linestyle='-')\n",
    "    plt.text(len(lengths)-1, mean_length, f'mean = {mean_length:.0f}', va='center', ha='left', backgroundcolor='w', fontsize=12)\n",
    "    plt.text(0, median_length, f'median = {median_length:.0f}', va='center', ha='right', backgroundcolor='w', fontsize=12)\n",
    "\n",
    "    plt.show()  # Display the plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e059b674",
   "metadata": {},
   "source": [
    "## Download Data\n",
    "\n",
    "The data used in this notebook is Milvus documentation web pages.\n",
    "\n",
    "The code block below downloads all the web pages into a local directory called `rtdocs`.  \n",
    "\n",
    "I've already uploaded the `rtdocs` data folder to github, so you should see it if you cloned my repo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "25686cc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # UNCOMMENT TO DOWNLOAD THE DOCS.\n",
    "\n",
    "# # !pip install -U langchain\n",
    "# from langchain_community.document_loaders import RecursiveUrlLoader\n",
    "\n",
    "# DOCS_PAGE=\"https://milvus.io/docs/\"\n",
    "\n",
    "# loader = RecursiveUrlLoader(DOCS_PAGE)\n",
    "# docs = loader.load()\n",
    "\n",
    "# num_documents = len(docs)\n",
    "# print(f\"loaded {num_documents} documents\")\n",
    "\n",
    "# # # Subset docs for faster testing\n",
    "# # docs = docs[5:7].copy()\n",
    "# # num_documents = len(docs)\n",
    "# # print(f\"testing with {num_documents} documents\")\n",
    "\n",
    "# # Print the type of the docs.\n",
    "# print(type(docs))\n",
    "# print(type(docs[0]))\n",
    "\n",
    "# docs[0].page_content[:500]\n",
    "\n",
    "# # UNCOMMENT TO SAVE THE DOCS LOCALLY.\n",
    "# OUTPUT_DIR = \"../../RAG/rtdocs_new/\"\n",
    "# os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
    "\n",
    "# # Convert each doc to HTML and save to the specified directory\n",
    "# for doc in docs:\n",
    "#     # Extract file name\n",
    "#     filename = doc.metadata['source'].split('/')[-1].replace(\".md\", \".html\")\n",
    "    \n",
    "#     # Check that filename is not empty\n",
    "#     if filename:\n",
    "#         with open(os.path.join(OUTPUT_DIR, filename), \"w\") as f:\n",
    "#             f.write(doc.page_content)\n",
    "#     else:\n",
    "#         print(\"Filename is empty. Skipping this doc.\")\n",
    "#         pprint.pprint(doc.metadata)\n",
    "#         pprint.pprint(doc.page_content[:500])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "075b55bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loaded 22 documents\n",
      "Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed Milvus FREE Search Home v2.4.x About Milvus Get StartedPrerequisitesInstall MilvusInstall SDKsQuickstart Concepts User Guide Models Administration Guide Tools Integrations Example Applications FAQs API reference Quickstart This guide explains how to connect to your Milvus cluster and performs CRUD operations in minutes Before you start You have installed Milvus standalone or Milvus cluster. You have installed preferred SDKs. You c\n",
      "{'source': 'https://milvus.io/docs/quickstart.md'}\n"
     ]
    }
   ],
   "source": [
    "# From raw docs\n",
    "\n",
    "# UNCOMMENT TO READ THE DOCS FROM A LOCAL DIRECTORY.\n",
    "\n",
    "# Read docs into LangChain\n",
    "# !pip install -U langchain\n",
    "# !pip install unstructured\n",
    "from langchain.document_loaders import DirectoryLoader\n",
    "\n",
    "# Load HTML files from a local directory\n",
    "path = \"../../RAG/rtdocs_new/\"\n",
    "global_pattern = '*.html'\n",
    "loader = DirectoryLoader(path=path, glob=global_pattern)\n",
    "docs = loader.load()\n",
    "\n",
    "num_documents = len(docs)\n",
    "print(f\"loaded {num_documents} documents\")\n",
    "\n",
    "# # Subset docs for faster testing\n",
    "# docs = docs[5:7].copy()\n",
    "# num_documents = len(docs)\n",
    "# print(f\"testing with {num_documents} documents\")\n",
    "\n",
    "# Inspect type of the docs and texts.\n",
    "# print(type(docs))\n",
    "# print(type(docs[0]))\n",
    "# print(docs[0].page_content[:500])\n",
    "\n",
    "# Clean up \\n literals and source metdata.\n",
    "for doc in docs:\n",
    "    doc.page_content = clean_text(doc.page_content)\n",
    "    doc.metadata[\"source\"] = \\\n",
    "        doc.metadata[\"source\"]\\\n",
    "            .replace(\"../../RAG/rtdocs_new\", \"https://milvus.io/docs\")\\\n",
    "            .replace(\".html\", \".md\")\n",
    "    \n",
    "print(docs[0].page_content[:500])\n",
    "pprint.pprint(docs[0].metadata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3d41373c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'https://milvus.io/docs/architecture_overview.md',\n",
       " 'https://milvus.io/docs/aws.md',\n",
       " 'https://milvus.io/docs/configure-docker.md',\n",
       " 'https://milvus.io/docs/deploy_s3.md',\n",
       " 'https://milvus.io/docs/embeddings.md',\n",
       " 'https://milvus.io/docs/get-and-scalar-query.md',\n",
       " 'https://milvus.io/docs/glossary.md',\n",
       " 'https://milvus.io/docs/gpu_index.md',\n",
       " 'https://milvus.io/docs/index-vector-fields.md',\n",
       " 'https://milvus.io/docs/index.md',\n",
       " 'https://milvus.io/docs/insert-update-delete.md',\n",
       " 'https://milvus.io/docs/install_standalone-docker.md',\n",
       " 'https://milvus.io/docs/manage-collections.md',\n",
       " 'https://milvus.io/docs/metric.md',\n",
       " 'https://milvus.io/docs/milvus-cdc-overview.md',\n",
       " 'https://milvus.io/docs/monitor_overview.md',\n",
       " 'https://milvus.io/docs/multi-vector-search.md',\n",
       " 'https://milvus.io/docs/quickstart.md',\n",
       " 'https://milvus.io/docs/rbac.md',\n",
       " 'https://milvus.io/docs/scaleout.md',\n",
       " 'https://milvus.io/docs/single-vector-search.md',\n",
       " 'https://milvus.io/docs/system_configuration.md'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List every unique source in docs.\n",
    "doc_sources = set([doc.metadata['source'] for doc in docs])\n",
    "print(len(doc_sources))\n",
    "doc_sources"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f19236fe",
   "metadata": {},
   "source": [
    "## Load the Embedding Model checkpoint and use it to create vector embeddings\n",
    "\n",
    "#### What are Embeddings?\n",
    "\n",
    "Check out [this blog](https://zilliz.com/glossary/vector-embeddings) for an introduction to embeddings.  \n",
    "\n",
    "An excellent place to start is by selecting an embedding model from the [HuggingFace MTEB Leaderboard](https://huggingface.co/spaces/mteb/leaderboard), sorted descending by the \"Retrieval Average'' column since this task is most relevant to RAG. Then, choose the smallest, highest-ranking embedding model. But, Beware!! some models listed are overfit to the training data, so they won't perform on your data as promised.  \n",
    "\n",
    "Milvus (and Zilliz) only supports tested embedding models that are **not overfit**!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b6c23fc",
   "metadata": {},
   "source": [
    "### Use open source Embedding Model from HuggingFace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2f338b22",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !python -m pip install --upgrade langchain_huggingface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f043c02e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from langchain_huggingface import HuggingFaceEmbeddings\n",
    "\n",
    "# # Use an embedding model.\n",
    "# model_name = \"BAAI/bge-large-en-v1.5\"\n",
    "# model_kwargs = {'device': 'cpu'}\n",
    "# encode_kwargs = {'normalize_embeddings': True}\n",
    "# embed_model = HuggingFaceEmbeddings(\n",
    "#     model_name=model_name,\n",
    "#     model_kwargs=model_kwargs,\n",
    "#     encode_kwargs=encode_kwargs\n",
    "# )\n",
    "# EMBEDDING_DIM = embed_model.dict()['client'].get_sentence_embedding_dimension()\n",
    "# print(f\"MODEL: {model_name}, EMBEDDING_DIM: {EMBEDDING_DIM}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f06c1cb0",
   "metadata": {},
   "source": [
    "### Use OpenAI Embedding model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "de45cdd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !python -m pip install --upgrade langchain_openai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1fab8a0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MODEL: text-embedding-3-small, EMBEDDING_DIM: 512\n"
     ]
    }
   ],
   "source": [
    "from langchain_openai.embeddings import OpenAIEmbeddings\n",
    "\n",
    "# 1. Get your API key: https://platform.openai.com/api-keys\n",
    "# 2. Save your api key in env variable.\n",
    "# https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n",
    "\n",
    "# 3. OpenAI embedding model name, `text-embedding-3-large` or `ext-embedding-3-small`.\n",
    "# release notes: https://openai.com/index/new-embedding-models-and-api-updates/\n",
    "model_name = \"text-embedding-3-small\"\n",
    "EMBEDDING_DIM = 512\n",
    "\n",
    "embed_model = OpenAIEmbeddings(\n",
    "    model=model_name,\n",
    "    dimensions=EMBEDDING_DIM,\n",
    ")\n",
    "print(f\"MODEL: {model_name}, EMBEDDING_DIM: {EMBEDDING_DIM}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "845b7cf4",
   "metadata": {},
   "source": [
    "## Setup LLM for Answer Generation (G-part of RAG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f9f40183",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define temperature for the LLM and random seed.\n",
    "TEMPERATURE = 0.1\n",
    "TOP_P = 0.9\n",
    "RANDOM_SEED = 415\n",
    "MAX_TOKENS = 512\n",
    "FREQUENCY_PENALTY = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b6a5cb5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length prompt: 406\n"
     ]
    }
   ],
   "source": [
    "from langchain.prompts import PromptTemplate\n",
    "\n",
    "prompt_template = \"\"\"First, check if the provided Context is relevant to \n",
    "the user's question.  Second, only if the provided Context is strongly relevant, \n",
    "answer the question using the Context.  Otherwise, if the Context is not \n",
    "strongly relevant, answer the question without using the Context.  \n",
    "Be clear, concise, relevant.  Answer clearly, in fewer than 2 sentences.\n",
    "User's question: {question}\n",
    "provided Context: {context}\n",
    "\"\"\"\n",
    "print(f\"Length prompt: {len(prompt_template)}\")\n",
    "\n",
    "PROMPT = PromptTemplate(\n",
    "    template=prompt_template, input_variables=[\"question\", \"context\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4ca8cfaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/miniconda3/envs/py311-unum/lib/python3.11/site-packages/langchain_core/utils/utils.py:161: UserWarning: WARNING! seed is not default parameter.\n",
      "                seed was transferred to model_kwargs.\n",
      "                Please confirm that seed is what you intended.\n",
      "  warnings.warn(\n",
      "/opt/miniconda3/envs/py311-unum/lib/python3.11/site-packages/langchain_core/utils/utils.py:161: UserWarning: WARNING! frequency_penalty is not default parameter.\n",
      "                frequency_penalty was transferred to model_kwargs.\n",
      "                Please confirm that frequency_penalty is what you intended.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# !python -m pip install -U langchain_openai\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "# Define the generation llm model to use.\n",
    "# https://openai.com/blog/new-embedding-models-and-api-updates\n",
    "# Customers using the pinned gpt-3.5-turbo model alias will be automatically upgraded to gpt-3.5-turbo-0125 two weeks after this model launches.\n",
    "LLM_NAME = \"gpt-3.5-turbo\"\n",
    "llm = ChatOpenAI(\n",
    "    model=LLM_NAME,\n",
    "    api_key=os.environ.get(\"OPENAI_API_KEY\"),\n",
    "    temperature=TEMPERATURE,\n",
    "    seed=RANDOM_SEED,\n",
    "    frequency_penalty=FREQUENCY_PENALTY\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8839bbc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_core.runnables import RunnablePassthrough, RunnableParallel\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "\n",
    "# Define a function to format documents into context text\n",
    "def format_docs(docs):\n",
    "    return \"\\n\\n\".join(doc.page_content for doc in docs)\n",
    "\n",
    "def execute_rag_chain(sample_retriever, sample_llm, sample_question):\n",
    "\n",
    "    # Define the RAG chain for generating answers with the LLM\n",
    "    rag_chain_from_docs = (\n",
    "        RunnablePassthrough.assign(context=lambda x: format_docs(x[\"context\"]))\n",
    "        | PROMPT\n",
    "        | sample_llm\n",
    "        | StrOutputParser()\n",
    "    )\n",
    "\n",
    "    # Define the chain that handles retrieval and combines with the LLM response\n",
    "    sample_rag_chain = RunnableParallel({\n",
    "            \"context\": sample_retriever, \n",
    "            \"question\": RunnablePassthrough()\n",
    "        }).assign(answer=rag_chain_from_docs)\n",
    "\n",
    "    # Invoke the chain with the sample question.\n",
    "    results = sample_rag_chain.invoke(sample_question)\n",
    "\n",
    "    # Extract the answer\n",
    "    print(\"Answer:\", results[\"answer\"])\n",
    "\n",
    "    # Extract unique sources from the context metadata.\n",
    "    unique_sources = []\n",
    "    for context in results[\"context\"]:\n",
    "        source = context.metadata['source']\n",
    "        if source not in unique_sources:\n",
    "            unique_sources.append(source)\n",
    "    print(f\"Sources: {unique_sources}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ac135e0",
   "metadata": {},
   "source": [
    "## Define 4 questions\n",
    "\n",
    "Search Milvus using [PyMilvus API](https://milvus.io/docs/search.md).\n",
    "\n",
    "💡 By their nature, vector searches are \"semantic\" searches.  For example, if you were to search for \"leaky faucet\": \n",
    "> **Traditional Key-word Search** - either or both words \"leaky\", \"faucet\" would have to match some text in order to return a web page or link text to the document.\n",
    "\n",
    "> **Semantic search** - results containing words \"drippy\" \"taps\" would be returned as well because these words mean the same thing even though they are different words.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "af71bbbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example query length: 75\n"
     ]
    }
   ],
   "source": [
    "# Define a sample question about your data.\n",
    "QUESTION1 = \"What do the parameters for HNSW mean?\"\n",
    "QUESTION2 = \"What are good default values for HNSW parameters with 25K vectors dim 1024?\"\n",
    "QUESTION3 = \"What does nlist vs nprobe mean in ivf_flat?\"\n",
    "QUESTION4 = \"What is the default AUTOINDEX index and vector field distance metric in Milvus?\"\n",
    "\n",
    "# In case you want to ask all the questions at once.\n",
    "QUERY = [QUESTION1, QUESTION2, QUESTION3, QUESTION4]\n",
    "\n",
    "# Inspect the length of one question.\n",
    "QUERY_LENGTH = len(QUESTION2)\n",
    "print(f\"example query length: {QUERY_LENGTH}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a358824f",
   "metadata": {},
   "source": [
    "## Small-to-big Chunking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "95e3f0f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !python -m pip install lxml\n",
    "from langchain_milvus import Milvus\n",
    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
    "from langchain.retrievers import ParentDocumentRetriever\n",
    "from langchain.storage import InMemoryStore\n",
    "import time, pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "439e3ead",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chunk_size: 512, chunk_overlap: 51.0\n",
      "22 docs split into 355 child documents.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "CHUNK_SIZE = 512\n",
    "chunk_overlap = np.round(CHUNK_SIZE * 0.10, 0)\n",
    "print(f\"chunk_size: {CHUNK_SIZE}, chunk_overlap: {chunk_overlap}\")\n",
    "\n",
    "# The splitter to create smaller (child) chunks\n",
    "# Default splitters: https://github.com/langchain-ai/langchain/blob/9ef2feb6747f5a69d186bd623b569ad722829a5e/libs/langchain/langchain/text_splitter.py#L842\n",
    "child_splitter = RecursiveCharacterTextSplitter(\n",
    "    chunk_size=CHUNK_SIZE, \n",
    "    chunk_overlap=chunk_overlap,\n",
    "    # length_function = len,  # use built-in Python len function\n",
    "    # separators = [\"\\n\\n\", \"\\n\", \" \", \". \", \"\"], # defaults\n",
    ")\n",
    "\n",
    "# Child docs for inspection\n",
    "sub_docs = child_splitter.split_documents(docs)\n",
    "print(f\"{len(docs)} docs split into {len(sub_docs)} child documents.\")\n",
    "\n",
    "# Inspect chunk lengths\n",
    "plot_chunk_lengths(sub_docs, 'Recursive Character')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "974b3572",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chunk_size: 1586\n",
      "22 docs split into 124 parent documents.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "PARENT_CHUNK_SIZE = 1586\n",
    "print(f\"chunk_size: {PARENT_CHUNK_SIZE}\")\n",
    "\n",
    "# The splitter to use to create bigger (parent) chunks\n",
    "parent_splitter = RecursiveCharacterTextSplitter(\n",
    "    chunk_size=PARENT_CHUNK_SIZE,\n",
    ")\n",
    "\n",
    "# Parent docs for inspection.\n",
    "parent_docs = parent_splitter.split_documents(docs)\n",
    "print(f\"{len(docs)} docs split into {len(parent_docs)} parent documents.\")\n",
    "\n",
    "# Inspect chunk lengths\n",
    "plot_chunk_lengths(parent_docs, 'Parent')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9f70e8bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop the existing vectorstore if it exists.\n",
    "try:\n",
    "    del vectorstore\n",
    "except:\n",
    "    pass\n",
    "\n",
    "# Create vectorstore for vector indexing and retrieval.\n",
    "COLLECTION_NAME = \"MilvusDocs\"\n",
    "vectorstore = Milvus(\n",
    "    collection_name=COLLECTION_NAME,\n",
    "    embedding_function=embed_model,\n",
    "    connection_args={\"uri\": \"./milvus_demo.db\"},\n",
    "    auto_id=True,\n",
    "    # Set to True to drop the existing collection if it exists.\n",
    "    drop_old=True,\n",
    ")\n",
    "\n",
    "# Create doc storage for the parent documents.\n",
    "store = InMemoryStore()\n",
    "\n",
    "# Create the ParentDocumentRetriever.\n",
    "retriever = ParentDocumentRetriever(\n",
    "    vectorstore=vectorstore, \n",
    "    docstore=store, \n",
    "    child_splitter=child_splitter,\n",
    "    parent_splitter=parent_splitter,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "aa70195c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# When we add documents two things will happen:\n",
    "# Parent chunks - docs split into large chunks.\n",
    "# Child chunks - docs split into into smaller chunks.\n",
    "# Relationship between parent and child is kept.\n",
    "retriever.add_documents(docs, ids=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "662289d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "124"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check how many parent docs are in the doc store.\n",
    "len(list(store.yield_keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15a26211",
   "metadata": {},
   "source": [
    "#### Test with questions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "98dc0fdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SELECT A PARTICULAR QUESTION TO ASK.\n",
    "SAMPLE_QUESTION = QUESTION4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "25f592e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question: What is the default AUTOINDEX index and vector field distance metric in Milvus?\n",
      "Result #1, len: 509\n",
      "chunk: True, and auto_id is enabled for the primary key. Additionally, a vector field is introduced, configured with a dimensionality of 768, along with the inclusion of four scalar fields, each with its respective attributes. Step 2: Set up index parameters Index parameters dictate how Milvus organizes your data within a collection. You can tailor the indexing process for specific fields by adjusting their metric_type and index_type. For the vector field, you have the flexibility to select COSINE, L2, or IP as\n",
      "(\"metadata: {'source': 'https://milvus.io/docs/manage-collections.md', \"\n",
      " \"'doc_id': '5a89935b-b42b-4844-9de7-281ad89c4a48', 'pk': 451033268878049347}\")\n",
      "Result #2, len: 506\n",
      "chunk: walks you through the basic operations on creating and managing indexes on vector fields in a collection. Overview Leveraging the metadata stored in an index file, Milvus organizes your data in a specialized structure, facilitating rapid retrieval of requested information during searches or queries. Milvus provides several index types to sort field values for efficient similarity searches. It also offers three metric types: Cosine Similarity (COSINE), Euclidean Distance (L2), and Inner Product (IP) to\n",
      "(\"metadata: {'source': 'https://milvus.io/docs/index-vector-fields.md', \"\n",
      " \"'doc_id': 'c774f98e-610c-4be2-ad43-b5970ad9b6c3', 'pk': 451033268878049637}\")\n",
      "sources: 2, ['https://milvus.io/docs/manage-collections.md', 'https://milvus.io/docs/index-vector-fields.md']\n"
     ]
    }
   ],
   "source": [
    "# The vector store alone will retrieve small chunks:\n",
    "TOP_K = 2\n",
    "child_results = vectorstore.similarity_search(\n",
    "    SAMPLE_QUESTION,\n",
    "    k=TOP_K)\n",
    "\n",
    "print(f\"Question: {SAMPLE_QUESTION}\")\n",
    "\n",
    "# Print the retrieved chunk and metadata.\n",
    "# Append each unique context and source to a list.\n",
    "contexts = []\n",
    "sources = []\n",
    "for i, child_result in enumerate(child_results):\n",
    "    context = child_result.page_content\n",
    "    print(f\"Result #{i+1}, len: {len(context)}\")\n",
    "    print(f\"chunk: {context}\")\n",
    "    pprint.pprint(f\"metadata: {child_result.metadata}\")\n",
    "    context = child_result.page_content\n",
    "    contexts.append(context)\n",
    "    source = child_result.metadata['source']\n",
    "    if source not in sources:\n",
    "        sources.append(source)\n",
    "\n",
    "print(f\"sources: {len(sources)}, {sources}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9f689165",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/miniconda3/envs/py311-unum/lib/python3.11/site-packages/langchain_core/_api/deprecation.py:139: LangChainDeprecationWarning: The method `BaseRetriever.get_relevant_documents` was deprecated in langchain-core 0.1.46 and will be removed in 0.3.0. Use invoke instead.\n",
      "  warn_deprecated(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num parent results: 4\n",
      "Result #1, len: 1583\n",
      "chunk: vector in the data to be inserted, are treated as dynamic fields. These additional fields are saved as key-value pairs within a special field named $meta. This feature allows the inclusion of extra fields during data insertion. The automatically indexed and loaded collection from the provided code is ready for immediate data insertions. Customized setup Instead of letting Milvus decide almost everything for your collection, you can determine the schema and index parameters of the collection on your own. Step 1: Set up schema A schema defines the structure of a collection. Within the schema, you have the option to enable or disable enable_dynamic_field, add pre-defined fields, and set attributes for each field. For a detailed explanation of the concept and available data types, refer to Schema Explained. Python Java Node.js In the provided code snippet for Python, the enable_dynamic_field is set to True, and auto_id is enabled for the primary key. Additionally, a vector field is introduced, configured with a dimensionality of 768, along with the inclusion of four scalar fields, each with its respective attributes. Step 2: Set up index parameters Index parameters dictate how Milvus organizes your data within a collection. You can tailor the indexing process for specific fields by adjusting their metric_type and index_type. For the vector field, you have the flexibility to select COSINE, L2, or IP as the metric_type. Python Java Node.js The code snippet above demonstrates how to set up index parameters for the vector field and a scalar field, respectively. For\n",
      "\"metadata: {'source': 'https://milvus.io/docs/manage-collections.md'}\"\n",
      "Result #2, len: 1582\n",
      "chunk: Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed Milvus FREE Search Home v2.4.x About Milvus Get Started Concepts User GuideManage DatabasesManage SchemaManage CollectionsManage IndexesIndex Vector FieldsIndex Scalar FieldsIndex with GPUManage PartitionsInsert, Upsert & DeleteData ImportSearch, Query & GetAdvanced Features Models Administration Guide Tools Integrations Example Applications FAQs API reference Index Vector Fields This guide walks you through the basic operations on creating and managing indexes on vector fields in a collection. Overview Leveraging the metadata stored in an index file, Milvus organizes your data in a specialized structure, facilitating rapid retrieval of requested information during searches or queries. Milvus provides several index types to sort field values for efficient similarity searches. It also offers three metric types: Cosine Similarity (COSINE), Euclidean Distance (L2), and Inner Product (IP) to measure the distances between vector embeddings. It is recommended to create indexes for both the vector field and scalar fields that are frequently accessed. The code snippets on this page use new MilvusClient (Python) to interact with Milvus. New MilvusClient SDKs for other languages will be released in future updates. Preparations As explained in Manage Collections, Milvus automatically generates an index and loads it into memory when creating a collection if any of the following conditions are specified in the collection creation request: The dimensionality of the vector field and the metric type, or The\n",
      "\"metadata: {'source': 'https://milvus.io/docs/index-vector-fields.md'}\"\n",
      "Result #3, len: 1581\n",
      "chunk: Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed Milvus FREE Search Home v2.4.x About Milvus Get Started ConceptsArchitectureBitsetConsistencyMulti-tenancyTimestampSimilarity MetricsTime SynchronizationVector IndexIn-memory IndexOn-disk IndexGPU IndexScalar IndexRerankingTerminology User Guide Models Administration Guide Tools Integrations Example Applications FAQs API reference In-memory Index This topic lists various types of in-memory indexes Milvus supports, scenarios each of them best suits, and parameters users can configure to achieve better search performance. For on-disk indexes, see On-disk Index. Indexing is the process of efficiently organizing data, and it plays a major role in making similarity search useful by dramatically accelerating time-consuming queries on large datasets. To improve query performance, you can specify an index type for each vector field. Currently, a vector field only supports one index type. Milvus automatically deletes the old index when switching the index type. ANNS vector indexes Most of the vector index types supported by Milvus use approximate nearest neighbors search (ANNS) algorithms. Compared with accurate retrieval, which is usually very time-consuming, the core idea of ANNS is no longer limited to returning the most accurate result, but only searching for neighbors of the target. ANNS improves retrieval efficiency by sacrificing accuracy within an acceptable range. According to the implementation methods, the ANNS vector index can be divided into four categories: Tree-based index Graph-based\n",
      "\"metadata: {'source': 'https://milvus.io/docs/index.md'}\"\n",
      "Result #4, len: 1583\n",
      "chunk: Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed Milvus FREE Search Home v2.4.x About Milvus Get Started ConceptsArchitectureBitsetConsistencyMulti-tenancyTimestampSimilarity MetricsTime SynchronizationVector IndexScalar IndexRerankingTerminology User Guide Models Administration Guide Tools Integrations Example Applications FAQs API reference Terminology AutoID AutoID is an attribute of the primary field that determines whether to enable AutoIncrement for the primary field. The value of AutoID is defined based on a timestamp. For more information, refer to create_schema. AutoIndex Milvus automatically decides the most appropriate index type and params for a specific field based on empirical data. This is ideal for situations when you do not need to control the specific index params. For more information, refer to add_index. Attu Attu is an all-in-one administration tool for Milvus that significantly reduces the complexity and cost of managing the system. Birdwatcher Birdwatcher is a debugging tool for Milvus that connects to etcd, allowing you to monitor the status of the Milvus server and make adjustments in real-time. It also supports etcd file backups, aiding developers in troubleshooting. Bulk Writer Bulk Writer is a data processing tool provided by Milvus SDKs (e.g. PyMilvus, Java SDK) , designed to convert raw datasets into a format compatible with Milvus for efficient importing. Bulk Insert Bulk Insert is an API that enhances writing performance by allowing multiple files to be imported in a single request, optimizing operations with\n",
      "\"metadata: {'source': 'https://milvus.io/docs/glossary.md'}\"\n"
     ]
    }
   ],
   "source": [
    "# Whereas the doc retriever will return the larger parent document:\n",
    "parent_results = retriever.get_relevant_documents(SAMPLE_QUESTION)\n",
    "\n",
    "# Print the retrieved chunk and metadata.\n",
    "print(f\"Num parent results: {len(parent_results)}\")\n",
    "for i, parent_result in enumerate(parent_results):\n",
    "    print(f\"Result #{i+1}, len: {len(parent_result.page_content)}\")\n",
    "    print(f\"chunk: {parent_result.page_content}\")\n",
    "    pprint.pprint(f\"metadata: {parent_result.metadata}\")\n",
    "\n",
    "assert parent_results[0].metadata['source'] == sources[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "cfd00033",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sources: https://milvus.io/docs/manage-collections.md\n",
      "Length long text to summarize: 1583\n"
     ]
    }
   ],
   "source": [
    "# Separate all the context together by space.\n",
    "contexts_combined = ' '.join(contexts)\n",
    "# Lance Martin, LangChain, says put best contexts at end.\n",
    "contexts_combined = ' '.join(reversed(contexts))\n",
    "\n",
    "# Separate all the unique sources together by comma.\n",
    "source_combined = ' '.join(reversed(list(dict.fromkeys(sources))))\n",
    "\n",
    "# Alternatively use the parent (bigger) chunks.\n",
    "contexts_combined = parent_results[0].page_content\n",
    "source_combined = sources[0]\n",
    "print(f\"sources: {source_combined}\")\n",
    "\n",
    "print(f\"Length long text to summarize: {len(contexts_combined)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "44242897",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete the Milvus collection and doc store.\n",
    "# del vectorstore, retriever, store"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdd8dc61",
   "metadata": {},
   "source": [
    "## Semantic Chunking\n",
    "\n",
    "This chunker works by determining when to \"break\" apart sentences. This is done by calculating cosine distances between adjacent sentences. Looking across all these cosine distances, look for outlier distances past some threshold.  These outlier distances determine when chunks are split.\n",
    "\n",
    "There are a few ways to determine what that threshold is, which are controlled by the breakpoint_threshold_type kwarg.\n",
    "\n",
    "- `percentile` (default) — In this method, any distances greater than X percentile is split into a chunk.\n",
    "\n",
    "- `standard_deviation` — In this method, any difference greater than X standard deviations is split.\n",
    "\n",
    "- `interquartile` — In this method, the interquartile distance is used to split chunks.\n",
    "\n",
    "- See Semantic Chunking [docs](https://python.langchain.com/v0.2/docs/how_to/semantic-chunker/#standard-deviation) and [api](https://api.python.langchain.com/en/latest/text_splitter/langchain_experimental.text_splitter.SemanticChunker.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5f70f228",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !python -m pip install langchain_experimental"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "fbef0dab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created 87 semantic documents from 22 in 10.94 seconds\n",
      "('Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed Milvus '\n",
      " 'FREE Search Home v2.4.x About Milvus Get StartedPrerequisitesInstall '\n",
      " 'MilvusInstall SDKsQuickstart Concepts User Guide Models Ad')\n",
      "{}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from langchain_experimental.text_splitter import SemanticChunker\n",
    "\n",
    "# Initialize the SemanticChunker with the embedding model.\n",
    "semantic_text_splitter = SemanticChunker(embed_model)\n",
    "\n",
    "semantic_docs = []\n",
    "start_time = time.time()\n",
    "for doc in docs:\n",
    "\n",
    "    # Split the doc into semantic chunks.\n",
    "    semantic_list = semantic_text_splitter.create_documents([doc.page_content])\n",
    "\n",
    "    # Append the list of semantic chunks to semantic_docs.\n",
    "    semantic_docs.extend(semantic_list)\n",
    "\n",
    "end_time = time.time()\n",
    "\n",
    "# Inspect chunk lengths\n",
    "print(f\"Created {len(semantic_docs)} semantic documents from {len(docs)} in {end_time - start_time:.2f} seconds\")\n",
    "pprint.pprint(semantic_docs[0].page_content[:200])\n",
    "pprint.pprint(semantic_docs[0].metadata)\n",
    "# Created 87 semantic documents from 22.\n",
    "\n",
    "# Inspect chunk lengths\n",
    "plot_chunk_lengths(semantic_docs, 'Semantic')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5f9383f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Use Percentile to determine breakpoints.\n",
    "# text_splitter = SemanticChunker(\n",
    "#     embed_model, \n",
    "#     breakpoint_threshold_type=\"percentile\",\n",
    "#     breakpoint_threshold_amount=0.99\n",
    "# )\n",
    "\n",
    "# semantic_docs = text_splitter.create_documents([all_page_contents])\n",
    "# print(f\"Created {len(semantic_docs)} semantic documents from {len(docs)}.\")\n",
    "\n",
    "# # Too many!\n",
    "# # Created 1138 semantic documents from 22."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "21fe960b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Use Standard Deviation to determine breakpoints.\n",
    "# text_splitter = SemanticChunker(\n",
    "#     embed_model, \n",
    "#     breakpoint_threshold_type=\"standard_deviation\",\n",
    "#     breakpoint_threshold_amount=0.80\n",
    "# )\n",
    "# semantic_docs = text_splitter.create_documents([all_page_contents])\n",
    "\n",
    "# print(f\"Created {len(semantic_docs)} semantic documents from {len(docs)}.\")\n",
    "# print(\", \".join(str(len(doc.page_content)) for doc in semantic_docs))\n",
    "# pprint.pprint(semantic_docs[0].page_content)\n",
    "\n",
    "# # Created 195 semantic documents from 22."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "5992bf6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created Milvus collection from 87 docs in 1.58 seconds\n"
     ]
    }
   ],
   "source": [
    "# Drop vectorstore if it exists.\n",
    "try:\n",
    "    del vectorstore\n",
    "except:\n",
    "    pass\n",
    "\n",
    "# Create vectorstore for vector index and retrieval.\n",
    "COLLECTION_NAME = \"MilvusDocs\"\n",
    "start_time = time.time()\n",
    "vectorstore = Milvus.from_documents(\n",
    "    collection_name=COLLECTION_NAME,\n",
    "    documents=semantic_docs,\n",
    "    embedding=embed_model,\n",
    "    connection_args={\"uri\": \"./milvus_demo.db\"},\n",
    "    # Override LangChain default values for Milvus.\n",
    "    consistency_level=\"Eventually\",\n",
    "    # auto_id=True,\n",
    "    drop_old=True,\n",
    "    index_params = {\n",
    "        \"metric_type\": \"COSINE\",\n",
    "        \"index_type\": \"AUTOINDEX\",\n",
    "        \"params\": {},}\n",
    ")\n",
    "end_time = time.time()\n",
    "print(f\"Created Milvus collection from {len(semantic_docs)} docs in {end_time - start_time:.2f} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e7dad5e",
   "metadata": {},
   "source": [
    "#### Test with questions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c41c0814",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SELECT A PARTICULAR QUESTION TO ASK.\n",
    "SAMPLE_QUESTION = QUESTION3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "90176c52",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question: What does nlist vs nprobe mean in ivf_flat?\n",
      "Result #1, len: 4834\n",
      "chunk: By adjusting nprobe, an ideal balance between accuracy and speed can be found for a given scenario. Query time increases sharply as both the number of target input vectors (nq), and the number of clusters to search (nprobe), increase. BIN_IVF_FLAT is the most basic BIN_IVF index, and the encoded data stored in each unit is consistent with the original data. Index building parameters Parameter Description Range nlist Number of cluster units [1, 65536] Search parameters Common search Parameter Description Range Default Value nprobe Number of units to query [1, nlist] 8 Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 SPARSE_INVERTED_INDEX Each dimension maintains a list of vectors that have a non-zero value at that dimension. During search, Milvus iterates through each dimension of the query vector and computes scores for vectors that have non-zero values in those dimensions. Index building parameters Parameter Description Range drop_ratio_build The proportion of small vector values that are excluded during the indexing process. This option allows fine-tuning of the indexing process, making a trade-off between efficiency and accuracy by disregarding small values when building the index. [0, 1] Search parameters Parameter Description Range drop_ratio_search The proportion of small vector values that are excluded during the search process. This option allows fine-tuning of the search process by specifying the ratio of the smallest values in the query vector to ignore. It helps balance search precision and performance. The smaller the value set for drop_ratio_search, the less these small values contribute to the final score. By ignoring some small values, search performance can be improved with minimal impact on accuracy. [0, 1] SPARSE_WAND This index shares similarities with SPARSE_INVERTED_INDEX, while it utilizes the Weak-AND algorithm to further reduce the number of full IP distance evaluations during the search process. Based on our testing, SPARSE_WAND generally outperforms other methods in terms of speed. However, its performance can deteriorate rapidly as the density of the vectors increases. To address this issue, introducing a non-zero drop_ratio_search can significantly enhance performance while only incurring minimal accuracy loss. For more information, refer to Sparse Vector. Index building parameters Parameter Description Range drop_ratio_build The proportion of small vector values that are excluded during the indexing process. This option allows fine-tuning of the indexing process, making a trade-off between efficiency and accuracy by disregarding small values when building the index. [0, 1] Search parameters Parameter Description Range drop_ratio_search The proportion of small vector values that are excluded during the search process. This option allows fine-tuning of the search process by specifying the ratio of the smallest values in the query vector to ignore. It helps balance search precision and performance. The smaller the value set for drop_ratio_search, the less these small values contribute to the final score. By ignoring some small values, search performance can be improved with minimal impact on accuracy. [0, 1] FAQ What is the difference between FLAT index and IVF_FLAT index? IVF_FLAT index divides a vector space into nlist clusters. If you keep the default value of nlist as 16384, Milvus compares the distances between the target vector and the centers of all 16384 clusters to get nprobe nearest clusters. Then Milvus compares the distances between the target vector and the vectors in the selected clusters to get the nearest vectors. Unlike IVF_FLAT, FLAT directly compares the distances between the target vector and each and every vector. Therefore, when the total number of vectors approximately equals nlist, IVF_FLAT and FLAT has little difference in the way of calculation required and search performance. But as the number of vectors grows to two times, three times, or n times of nlist, IVF_FLAT index begins to show increasingly greater advantages. See How to Choose an Index in Milvus for more information. What's next Learn more about the Similarity Metrics supported in Milvus. Edit this page Report a bug Request doc changes On this page In-memory IndexANNS vector indexesIndexes supported in MilvusFAQWhat's next Resources Docs Blog Managed service Tutorials Bootcamp Demo Video Tools Attu Milvus CLI Sizing Tool Milvus backup tool Community Get involved Discord GitHub Milvus. 2024 All rights reserved.\n",
      "\"metadata: {'pk': 451033272369021860}\"\n",
      "Result #2, len: 6794\n",
      "chunk: Guarantee exact search results. BIN_IVF_FLAT Quantization-based index High-speed query Requires a recall rate as high as possible Supported index Classification Scenario SPARSE_INVERTED_INDEX Inverted index Depends on relatively small datasets. Requires a 100% recall rate. SPARSE_WAND Inverted index Weak-AND algorithm accelerated Can get a significant speed improvement while only sacrificing a small amount of recall. FLAT For vector similarity search applications that require perfect accuracy and depend on relatively small (million-scale) datasets, the FLAT index is a good choice. FLAT does not compress vectors, and is the only index that can guarantee exact search results. Results from FLAT can also be used as a point of comparison for results produced by other indexes that have less than 100% recall. FLAT is accurate because it takes an exhaustive approach to search, which means for each query the target input is compared to every set of vectors in a dataset. This makes FLAT the slowest index on our list, and poorly suited for querying massive vector data. There are no parameters required for the FLAT index in Milvus, and using it does not need data training. Search parameters Parameter Description Range metric_type [Optional] The chosen distance metric. See Supported Metrics. IVF_FLAT IVF_FLAT divides vector data into nlist cluster units, and then compares distances between the target input vector and the center of each cluster. Depending on the number of clusters the system is set to query (nprobe), similarity search results are returned based on comparisons between the target input and the vectors in the most similar cluster(s) only – drastically reducing query time. By adjusting nprobe, an ideal balance between accuracy and speed can be found for a given scenario. Results from the IVF_FLAT performance test demonstrate that query time increases sharply as both the number of target input vectors (nq), and the number of clusters to search (nprobe), increase. IVF_FLAT is the most basic IVF index, and the encoded data stored in each unit is consistent with the original data. Index building parameters Parameter Description Range Default Value nlist Number of cluster units [1, 65536] 128 Search parameters Common search Parameter Description Range Default Value nprobe Number of units to query [1, nlist] 8 Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 IVF_SQ8 IVF_FLAT does not perform any compression, so the index files it produces are roughly the same size as the original, raw non-indexed vector data. For example, if the original 1B SIFT dataset is 476 GB, its IVF_FLAT index files will be slightly smaller (~470 GB). Loading all the index files into memory will consume 470 GB of storage. When disk, CPU, or GPU memory resources are limited, IVF_SQ8 is a better option than IVF_FLAT. This index type can convert each FLOAT (4 bytes) to UINT8 (1 byte) by performing Scalar Quantization (SQ). This reduces disk, CPU, and GPU memory consumption by 70—75%. For the 1B SIFT dataset, the IVF_SQ8 index files require just 140 GB of storage. Index building parameters Parameter Description Range nlist Number of cluster units [1, 65536] Search parameters Common search Parameter Description Range Default Value nprobe Number of units to query [1, nlist] 8 Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 IVF_PQ PQ (Product Quantization) uniformly decomposes the original high-dimensional vector space into Cartesian products of m low-dimensional vector spaces, and then quantizes the decomposed low-dimensional vector spaces. Instead of calculating the distances between the target vector and the center of all the units, product quantization enables the calculation of distances between the target vector and the clustering center of each low-dimensional space and greatly reduces the time complexity and space complexity of the algorithm. IVF_PQ performs IVF index clustering before quantizing the product of vectors. Its index file is even smaller than IVF_SQ8, but it also causes a loss of accuracy during searching vectors. Index building parameters and search parameters vary with Milvus distribution. Select your Milvus distribution first. Index building parameters Parameter Description Range nlist Number of cluster units [1, 65536] m Number of factors of product quantization dim mod m == 0 nbits [Optional] Number of bits in which each low-dimensional vector is stored. [1, 16] (8 by default) Search parameters Common search Parameter Description Range Default Value nprobe Number of units to query [1, nlist] 8 Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 SCANN SCANN (Score-aware quantization loss) is similar to IVF_PQ in terms of vector clustering and product quantization. What makes them different lies in the implementation details of product quantization and the use of SIMD (Single-Instruction / Multi-data) for efficient calculation. Index building parameters Parameter Description Range nlist Number of cluster units [1, 65536] with_raw_data Whether to include the raw data in the index True or False. Defaults to True. Unlike IVF_PQ, default values apply to m and nbits for optimized performance. Search parameters Common search Parameter Description Range Default value nprobe Number of units to query [1, nlist] reorder_k Number of candidate units to query [top_k, â] Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 HNSW HNSW (Hierarchical Navigable Small World Graph) is a graph-based indexing algorithm.\n",
      "\"metadata: {'pk': 451033272369021857}\"\n"
     ]
    }
   ],
   "source": [
    "# Retrieve semantic chunks.\n",
    "TOP_K = 2\n",
    "semantic_retriever = vectorstore.as_retriever(search_kwargs={\"k\" : TOP_K})\n",
    "semantic_results = semantic_retriever.invoke(SAMPLE_QUESTION)\n",
    "\n",
    "print(f\"Question: {SAMPLE_QUESTION}\")\n",
    "\n",
    "# Print the retrieved chunk and metadata.\n",
    "contexts = []\n",
    "# sources = []\n",
    "for i, semantic_result in enumerate(semantic_results):\n",
    "    context = semantic_result.page_content\n",
    "    print(f\"Result #{i+1}, len: {len(context)}\")\n",
    "    print(f\"chunk: {context}\")\n",
    "    pprint.pprint(f\"metadata: {semantic_result.metadata}\")\n",
    "\n",
    "    # Keep a copy of all the contexts and sources.\n",
    "    contexts.append(context)\n",
    "    # source = semantic_result.metadata['source']\n",
    "    # if source not in sources:\n",
    "    #     sources.append(source)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e0d00d14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length long text to summarize: 11629\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"By adjusting nprobe, an ideal balance between accuracy and speed can be found for a given scenario. Query time increases sharply as both the number of target input vectors (nq), and the number of clusters to search (nprobe), increase. BIN_IVF_FLAT is the most basic BIN_IVF index, and the encoded data stored in each unit is consistent with the original data. Index building parameters Parameter Description Range nlist Number of cluster units [1, 65536] Search parameters Common search Parameter Description Range Default Value nprobe Number of units to query [1, nlist] 8 Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 SPARSE_INVERTED_INDEX Each dimension maintains a list of vectors that have a non-zero value at that dimension. During search, Milvus iterates through each dimension of the query vector and computes scores for vectors that have non-zero values in those dimensions. Index building parameters Parameter Description Range drop_ratio_build The proportion of small vector values that are excluded during the indexing process. This option allows fine-tuning of the indexing process, making a trade-off between efficiency and accuracy by disregarding small values when building the index. [0, 1] Search parameters Parameter Description Range drop_ratio_search The proportion of small vector values that are excluded during the search process. This option allows fine-tuning of the search process by specifying the ratio of the smallest values in the query vector to ignore. It helps balance search precision and performance. The smaller the value set for drop_ratio_search, the less these small values contribute to the final score. By ignoring some small values, search performance can be improved with minimal impact on accuracy. [0, 1] SPARSE_WAND This index shares similarities with SPARSE_INVERTED_INDEX, while it utilizes the Weak-AND algorithm to further reduce the number of full IP distance evaluations during the search process. Based on our testing, SPARSE_WAND generally outperforms other methods in terms of speed. However, its performance can deteriorate rapidly as the density of the vectors increases. To address this issue, introducing a non-zero drop_ratio_search can significantly enhance performance while only incurring minimal accuracy loss. For more information, refer to Sparse Vector. Index building parameters Parameter Description Range drop_ratio_build The proportion of small vector values that are excluded during the indexing process. This option allows fine-tuning of the indexing process, making a trade-off between efficiency and accuracy by disregarding small values when building the index. [0, 1] Search parameters Parameter Description Range drop_ratio_search The proportion of small vector values that are excluded during the search process. This option allows fine-tuning of the search process by specifying the ratio of the smallest values in the query vector to ignore. It helps balance search precision and performance. The smaller the value set for drop_ratio_search, the less these small values contribute to the final score. By ignoring some small values, search performance can be improved with minimal impact on accuracy. [0, 1] FAQ What is the difference between FLAT index and IVF_FLAT index? IVF_FLAT index divides a vector space into nlist clusters. If you keep the default value of nlist as 16384, Milvus compares the distances between the target vector and the centers of all 16384 clusters to get nprobe nearest clusters. Then Milvus compares the distances between the target vector and the vectors in the selected clusters to get the nearest vectors. Unlike IVF_FLAT, FLAT directly compares the distances between the target vector and each and every vector. Therefore, when the total number of vectors approximately equals nlist, IVF_FLAT and FLAT has little difference in the way of calculation required and search performance. But as the number of vectors grows to two times, three times, or n times of nlist, IVF_FLAT index begins to show increasingly greater advantages. See How to Choose an Index in Milvus for more information. What's next Learn more about the Similarity Metrics supported in Milvus. Edit this page Report a bug Request doc changes On this page In-memory IndexANNS vector indexesIndexes supported in MilvusFAQWhat's next Resources Docs Blog Managed service Tutorials Bootcamp Demo Video Tools Attu Milvus CLI Sizing Tool Milvus backup tool Community Get involved Discord GitHub Milvus. 2024 All rights reserved. Guarantee exact search results. BIN_IVF_FLAT Quantization-based index High-speed query Requires a recall rate as high as possible Supported index Classification Scenario SPARSE_INVERTED_INDEX Inverted index Depends on relatively small datasets. Requires a 100% recall rate. SPARSE_WAND Inverted index Weak-AND algorithm accelerated Can get a significant speed improvement while only sacrificing a small amount of recall. FLAT For vector similarity search applications that require perfect accuracy and depend on relatively small (million-scale) datasets, the FLAT index is a good choice. FLAT does not compress vectors, and is the only index that can guarantee exact search results. Results from FLAT can also be used as a point of comparison for results produced by other indexes that have less than 100% recall. FLAT is accurate because it takes an exhaustive approach to search, which means for each query the target input is compared to every set of vectors in a dataset. This makes FLAT the slowest index on our list, and poorly suited for querying massive vector data. There are no parameters required for the FLAT index in Milvus, and using it does not need data training. Search parameters Parameter Description Range metric_type [Optional] The chosen distance metric. See Supported Metrics. IVF_FLAT IVF_FLAT divides vector data into nlist cluster units, and then compares distances between the target input vector and the center of each cluster. Depending on the number of clusters the system is set to query (nprobe), similarity search results are returned based on comparisons between the target input and the vectors in the most similar cluster(s) only – drastically reducing query time. By adjusting nprobe, an ideal balance between accuracy and speed can be found for a given scenario. Results from the IVF_FLAT performance test demonstrate that query time increases sharply as both the number of target input vectors (nq), and the number of clusters to search (nprobe), increase. IVF_FLAT is the most basic IVF index, and the encoded data stored in each unit is consistent with the original data. Index building parameters Parameter Description Range Default Value nlist Number of cluster units [1, 65536] 128 Search parameters Common search Parameter Description Range Default Value nprobe Number of units to query [1, nlist] 8 Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 IVF_SQ8 IVF_FLAT does not perform any compression, so the index files it produces are roughly the same size as the original, raw non-indexed vector data. For example, if the original 1B SIFT dataset is 476 GB, its IVF_FLAT index files will be slightly smaller (~470 GB). Loading all the index files into memory will consume 470 GB of storage. When disk, CPU, or GPU memory resources are limited, IVF_SQ8 is a better option than IVF_FLAT. This index type can convert each FLOAT (4 bytes) to UINT8 (1 byte) by performing Scalar Quantization (SQ). This reduces disk, CPU, and GPU memory consumption by 70—75%. For the 1B SIFT dataset, the IVF_SQ8 index files require just 140 GB of storage. Index building parameters Parameter Description Range nlist Number of cluster units [1, 65536] Search parameters Common search Parameter Description Range Default Value nprobe Number of units to query [1, nlist] 8 Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 IVF_PQ PQ (Product Quantization) uniformly decomposes the original high-dimensional vector space into Cartesian products of m low-dimensional vector spaces, and then quantizes the decomposed low-dimensional vector spaces. Instead of calculating the distances between the target vector and the center of all the units, product quantization enables the calculation of distances between the target vector and the clustering center of each low-dimensional space and greatly reduces the time complexity and space complexity of the algorithm. IVF_PQ performs IVF index clustering before quantizing the product of vectors. Its index file is even smaller than IVF_SQ8, but it also causes a loss of accuracy during searching vectors. Index building parameters and search parameters vary with Milvus distribution. Select your Milvus distribution first. Index building parameters Parameter Description Range nlist Number of cluster units [1, 65536] m Number of factors of product quantization dim mod m == 0 nbits [Optional] Number of bits in which each low-dimensional vector is stored. [1, 16] (8 by default) Search parameters Common search Parameter Description Range Default Value nprobe Number of units to query [1, nlist] 8 Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 SCANN SCANN (Score-aware quantization loss) is similar to IVF_PQ in terms of vector clustering and product quantization. What makes them different lies in the implementation details of product quantization and the use of SIMD (Single-Instruction / Multi-data) for efficient calculation. Index building parameters Parameter Description Range nlist Number of cluster units [1, 65536] with_raw_data Whether to include the raw data in the index True or False. Defaults to True. Unlike IVF_PQ, default values apply to m and nbits for optimized performance. Search parameters Common search Parameter Description Range Default value nprobe Number of units to query [1, nlist] reorder_k Number of candidate units to query [top_k, â\\x88\\x9e] Range search Parameter Description Range Default Value max_empty_result_buckets Maximum number of buckets not returning any search results.This is a range-search parameter and terminates the search process whilst the number of consecutive empty buckets reaches the specified value.Increasing this value can improve recall rate at the cost of increased search time. [1, 65535] 2 HNSW HNSW (Hierarchical Navigable Small World Graph) is a graph-based indexing algorithm.\""
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Separate all the context together by space.\n",
    "contexts_combined = ' '.join(contexts)\n",
    "\n",
    "print(f\"Length long text to summarize: {len(contexts_combined)}\")\n",
    "contexts_combined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c06d4c2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete the Milvus collection and vectorstore.\n",
    "# del vectorstore"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0804d3ff",
   "metadata": {},
   "source": [
    "## HTML Chunking using LangChain\n",
    "\n",
    "Before embedding, it is necessary to decide your chunk strategy, chunk size, and chunk overlap.  This section uses:\n",
    "- **Strategy** = Use markdown header hierarchies.  Keep markdown sections together unless they are too long.\n",
    "- **Chunk size** = Use the embedding model's parameter `MAX_SEQ_LENGTH`\n",
    "- **Overlap** = Rule-of-thumb 10-15%\n",
    "- **Function** = \n",
    "  - Langchain's `HTMLHeaderTextSplitter` to split markdown sections.\n",
    "  - Langchain's `RecursiveCharacterTextSplitter` to split up long reviews recursively.\n",
    "\n",
    "\n",
    "Notice below, each chunk is grounded with the document source page.  <br>\n",
    "In addition, header titles are kept together with the chunk of markdown text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "267b0520",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loaded 22 documents\n",
      "<class 'list'>\n",
      "<class 'langchain_core.documents.base.Document'>\n",
      "<!DOCTYPE html><html lang=\"en\"><head><meta charSet=\"utf-8\"/><meta name=\"viewport\" content=\"width=device-width\"/><link rel=\"icon\" href=\"/favicon-32x32.png\"/><meta name=\"image\" property=\"og:image\" content=\"https://assets.zilliz.com/meta_image_milvus_d6510e10e0.png\"/><meta property=\"og:type\" content=\"WebSite\"/><title>Enable RBAC | Milvus Documentation</title><meta name=\"description\" content=\"Learn how to manage users, roles, and privileges. | v2.4.x\"/><meta property=\"og:title\" content=\"Enable RBAC \n",
      "{'content_type': 'text/html',\n",
      " 'description': 'Learn how to manage users, roles, and privileges. | v2.4.x',\n",
      " 'language': 'en',\n",
      " 'source': 'https://milvus.io/docs/rbac.md',\n",
      " 'title': 'Enable RBAC | Milvus Documentation'}\n"
     ]
    }
   ],
   "source": [
    "# DOWNLOAD THE DOCS.\n",
    "\n",
    "# !pip install -U langchain\n",
    "from langchain_community.document_loaders import RecursiveUrlLoader\n",
    "\n",
    "DOCS_PAGE=\"https://milvus.io/docs/\"\n",
    "\n",
    "loader = RecursiveUrlLoader(DOCS_PAGE)\n",
    "raw_html_docs = loader.load()\n",
    "# Drop 0th doc due to empty content.\n",
    "raw_html_docs = raw_html_docs[1:]\n",
    "\n",
    "num_documents = len(raw_html_docs)\n",
    "print(f\"loaded {num_documents} documents\")\n",
    "\n",
    "# # Subset docs for faster testing\n",
    "# raw_html_docs = raw_html_docs[5:7].copy()\n",
    "# num_documents = len(raw_html_docs)\n",
    "# print(f\"testing with {num_documents} documents\")\n",
    "\n",
    "# Clean up \\n literals and source metdata.\n",
    "for doc in raw_html_docs:\n",
    "    doc.page_content = clean_text(doc.page_content)\n",
    "    doc.metadata[\"source\"] = \\\n",
    "        doc.metadata[\"source\"]\\\n",
    "            .replace(\"../../RAG/rtdocs_new\", \"https://milvus.io/docs\")\\\n",
    "            .replace(\".html\", \".md\")\n",
    "\n",
    "# Print the type of the docs.\n",
    "print(type(raw_html_docs))\n",
    "print(type(raw_html_docs[0]))\n",
    "\n",
    "# Check the raw HTML docs.\n",
    "print(raw_html_docs[0].page_content[:500])\n",
    "pprint.pprint(raw_html_docs[0].metadata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "83084872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<!DOCTYPE html><html lang=\"en\"><head><meta charSet=\"utf-8\"/><meta name=\"viewport\" content=\"width=device-width\"/><link rel=\"icon\" href=\"/favicon-32x32.png\"/><meta name=\"image\" property=\"og:image\" content=\"https://assets.zilliz.com/meta_image_milvus_d6510e10e0.png\"/><meta property=\"og:type\" content=\"WebSite\"/><title>Enable RBAC | Milvus Documentation</title><meta name=\"description\" content=\"Learn how to manage users, roles, and privileges. | v2.4.x\"/><meta property=\"og:title\" content=\"Enable RBAC \n",
      "{'content_type': 'text/html',\n",
      " 'description': 'Learn how to manage users, roles, and privileges. | v2.4.x',\n",
      " 'language': 'en',\n",
      " 'source': 'https://milvus.io/docs/rbac.md',\n",
      " 'title': 'Enable RBAC | Milvus Documentation'}\n"
     ]
    }
   ],
   "source": [
    "# Check the raw docs again.\n",
    "print(raw_html_docs[0].page_content[:500])\n",
    "pprint.pprint(raw_html_docs[0].metadata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "debdeab1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'https://milvus.io/docs/architecture_overview.md',\n",
       " 'https://milvus.io/docs/aws.md',\n",
       " 'https://milvus.io/docs/configure-docker.md',\n",
       " 'https://milvus.io/docs/deploy_s3.md',\n",
       " 'https://milvus.io/docs/embeddings.md',\n",
       " 'https://milvus.io/docs/get-and-scalar-query.md',\n",
       " 'https://milvus.io/docs/glossary.md',\n",
       " 'https://milvus.io/docs/gpu_index.md',\n",
       " 'https://milvus.io/docs/index-vector-fields.md',\n",
       " 'https://milvus.io/docs/index.md',\n",
       " 'https://milvus.io/docs/insert-update-delete.md',\n",
       " 'https://milvus.io/docs/install_standalone-docker.md',\n",
       " 'https://milvus.io/docs/manage-collections.md',\n",
       " 'https://milvus.io/docs/metric.md',\n",
       " 'https://milvus.io/docs/milvus-cdc-overview.md',\n",
       " 'https://milvus.io/docs/monitor_overview.md',\n",
       " 'https://milvus.io/docs/multi-vector-search.md',\n",
       " 'https://milvus.io/docs/quickstart.md',\n",
       " 'https://milvus.io/docs/rbac.md',\n",
       " 'https://milvus.io/docs/scaleout.md',\n",
       " 'https://milvus.io/docs/single-vector-search.md',\n",
       " 'https://milvus.io/docs/system_configuration.md'}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List every unique source in raw_html_docs.\n",
    "raw_html_doc_sources = set([doc.metadata['source'] for doc in raw_html_docs])\n",
    "print(len(raw_html_doc_sources))\n",
    "raw_html_doc_sources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "a9b8a0da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pattern for splitting: <h[1-3][^>]*>\n",
      "docs: 22, split into 66 html chunks.\n",
      "Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed Milvus FREE Search Home v2.4.x About Milvus Get StartedPrerequisitesInstall MilvusInstall SDKsQuickstart Concepts User Guide Models Ad\n",
      "{'h1': 'Enable RBAC', 'h2': '1. Initiate a Milvus clie', 'h3': '2. Create a user', 'source': 'https://milvus.io/docs/glossary.md', 'doc_index': '3f184da0-d093-4eca-84c9-a20a7f4495b4'}\n"
     ]
    }
   ],
   "source": [
    "# !python -m pip install lxml\n",
    "from langchain.text_splitter import HTMLHeaderTextSplitter, RecursiveCharacterTextSplitter\n",
    "from langchain_core.documents.base import Document\n",
    "import uuid, re, html\n",
    "\n",
    "doc_ids = [str(uuid.uuid4()) for _ in raw_html_docs]\n",
    "\n",
    "# Define the headers to split on for the HTMLHeaderTextSplitter\n",
    "headers_to_split_on = [\n",
    "    (\"<h1>\", \"Header 1\"),\n",
    "    (\"<h2>\", \"Header 2\"),\n",
    "    (\"<h3>\", \"Header 3\"),\n",
    "]\n",
    "# Create an instance of the HTMLHeaderTextSplitter\n",
    "html_splitter = HTMLHeaderTextSplitter(\n",
    "    headers_to_split_on,\n",
    "    # Return each element together with their associated headers\n",
    "    return_each_element=True,\n",
    ")\n",
    "\n",
    "# TODO: Clean up this scratch code later.\n",
    "# Milvus docs don't have simple h1, h2, h3 tags.\n",
    "# Construct a regex pattern to match any of the specified headers.\n",
    "pattern = r\"<h[1-3][^>]*>\"\n",
    "print(\"Pattern for splitting:\", pattern)\n",
    "\n",
    "# Function to remove all HTML tags\n",
    "def remove_html_tags(text):\n",
    "    return re.sub(r\"<[^>]+>\", \"\", text)\n",
    "def remove_extra_spaces(text):\n",
    "    # Replace three or more spaces with a single space\n",
    "    return re.sub(r' {3,}', ' ', text)\n",
    "def remove_html_markup(text):\n",
    "    # Pattern to match opening and closing tags, including attributes within the tags\n",
    "    pattern = r\"<[^>]+>.*?</[^>]+>\"\n",
    "    clean_text = re.sub(pattern, \"\", text)\n",
    "    pattern = r\"<[^>]+>\"\n",
    "    clean_text = re.sub(pattern, \"\", text)\n",
    "    return clean_text\n",
    "\n",
    "# Split the HTML text using the HTMLHeaderTextSplitter.\n",
    "new_docs = []\n",
    "for doc_id, html_doc, parsed_doc in zip(doc_ids, raw_html_docs, docs):\n",
    "\n",
    "    # Grab the headers\n",
    "    new_text = html_doc.page_content.replace('\\n', ' ')\n",
    "    html_split_list = re.split(pattern, new_text)\n",
    "\n",
    "    # Remove HTML tags from each extracted header text\n",
    "    headers_list = [remove_html_tags(header) for header in html_split_list]\n",
    "    # print(html_split_list[0])\n",
    "    # print(f\"Split into {len(html_split_list)} parts.\")\n",
    "\n",
    "    # Split the text into chunks using the HTMLHeaderTextSplitter.\n",
    "    # splits = html_splitter.split_text(doc.page_content)\n",
    "    splits = html_split_list\n",
    "\n",
    "    for split in splits:\n",
    "        # Initialize a temp Document object.\n",
    "        temp = Document(page_content=split)\n",
    "        temp.page_content = parsed_doc.page_content\n",
    "\n",
    "        # Assemble the metadata.\n",
    "        metadata = {}\n",
    "        # Handle exception if h1 does not exist.\n",
    "        try:\n",
    "            header_value1 = headers_list[1].strip().split(\"  \")[0][:25]\n",
    "            metadata[\"h1\"] = header_value1\n",
    "            # print(f\"header_name: h1, header_value: {header_value1}\")\n",
    "        except:\n",
    "            pass\n",
    "        # Handle exception if h2 does not exist.\n",
    "        try:\n",
    "            header_value2 = headers_list[2].strip().split(\"  \")[0][:25]\n",
    "            if len(header_value2) <= 0:\n",
    "                header_value2 = headers_list[3].strip().split(\"  \")[0][:25]\n",
    "            metadata[\"h2\"] = header_value2\n",
    "            # print(f\"header_name: h2, header_value: {header_value2}\")\n",
    "        except:\n",
    "            pass\n",
    "        # Handle exception if h2 does not exist.\n",
    "        try:\n",
    "            header_value3 = headers_list[3].strip().split(\"  \")[0][:25]\n",
    "            if (len(header_value3) <= 0 or header_value3 == header_value2):\n",
    "                header_value3 = headers_list[4].strip().split(\"  \")[0][:25]\n",
    "            if header_value3 == header_value2:\n",
    "                header_value3 = headers_list[5].strip().split(\"  \")[0][:25]\n",
    "            metadata[\"h3\"] = header_value3\n",
    "            # print(f\"header_name: h3, header_value: {header_value3}\")\n",
    "        except:\n",
    "            pass\n",
    "        temp.metadata = {\n",
    "            **metadata,\n",
    "            \"source\": doc.metadata[\"source\"]\\\n",
    "                .replace(\"../../RAG/rtdocs_new\", \"https://milvus.io/docs\")\\\n",
    "                .replace(\".html\", \".md\"),\n",
    "            'doc_index': doc_id\n",
    "        }\n",
    "\n",
    "        # Match page content with parsed page content.\n",
    "        temp.page_content = parsed_doc.page_content\n",
    "        try:\n",
    "            start_index = str.find(parsed_doc.page_content, header_value1)\n",
    "            end_index = str.find(parsed_doc.page_content, header_value2)\n",
    "            if start_index != -1 and end_index != -1:\n",
    "                # print(\"Found h1, h2\")\n",
    "                # print(parsed_doc.page_content[start_index:end_index])\n",
    "                temp.page_content = parsed_doc.page_content[start_index:end_index]\n",
    "                temp.page_content = remove_html_markup(temp.page_content).replace('\\n', ' ')\n",
    "                temp.page_content = remove_extra_spaces(temp.page_content).strip()\n",
    "        except:\n",
    "            pass\n",
    "        try:\n",
    "            start_index = str.find(parsed_doc.page_content, header_value2)\n",
    "            end_index = str.find(parsed_doc.page_content, header_value3)\n",
    "            if start_index != -1 and end_index != -1:\n",
    "                temp.page_content = parsed_doc.page_content[start_index:end_index]\n",
    "                temp.page_content = remove_html_markup(temp.page_content).replace('\\n', ' ')\n",
    "                temp.page_content = remove_extra_spaces(temp.page_content).strip()\n",
    "            # print(\"Found h2, h3\")\n",
    "        except:\n",
    "            pass\n",
    "        try:\n",
    "            start_index = str.find(parsed_doc.page_content, header_value3)\n",
    "            if start_index != -1:\n",
    "                temp.page_content = parsed_doc.page_content[start_index:]\n",
    "                temp.page_content = remove_html_markup(temp.page_content).replace('\\n', ' ')\n",
    "                temp.page_content = remove_extra_spaces(temp.page_content).strip()\n",
    "            # print(\"Found h3\")\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "    new_docs.extend(temp)\n",
    "\n",
    "html_docs = []\n",
    "for content in new_docs:\n",
    "    # Assuming each 'content' is a tuple or list with [page_content, metadata]\n",
    "    page_content, metadata = content  # This line unpacks the tuple or list\n",
    "\n",
    "    # Ensure page_content is a string\n",
    "    if isinstance(metadata, str) and metadata != \"Document\":\n",
    "        html_doc = Document(page_content=metadata)\n",
    "    elif isinstance(metadata, dict):\n",
    "        html_doc.metadata = metadata\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "    html_docs.append(html_doc)\n",
    "\n",
    "# Inspect chunk lengths\n",
    "print(f\"docs: {len(docs)}, split into {len(html_docs)} html chunks.\")\n",
    "print(html_docs[0].page_content[:200])\n",
    "print(html_docs[0].metadata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "f51def0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66 <class 'langchain_core.documents.base.Document'>\n",
      "Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed Milvus FREE Search Home v2.4.x About Milvus Get Started Concepts User Guide Models Administration GuideDeploymentConfigurationManage DependenciesWith Docker or HelmObject StorageMeta StorageMessage StorageWith Milvus OperatorScalingUpgradeMonitoring, Alerts & LogsSecurity Tools Integrations Example Applications FAQs API reference Configure Object Storage with Docker Compose or Helm Milvus uses MinIO for object storage by default, but it also supports using Amazon Simple Storage Service (S3) as persistent object storage for log and index files. This topic describes how to configure S3 for Milvus. You can skip this topic if you are satisfied with MinIO. You can configure S3 with Docker Compose or on K8s. Configure S3 with Docker Compose 1. Configure S3 MinIO is compatible with S3. To configure S3 with Docker Compose, provide your values for the minio section in the milvus.yaml file on the milvus/configs path. See MinIO/S3 Configurations for more information. 2. Refine docker-compose.yaml You'd also remove the MINIO_ADDRESS environment variable for milvus service at docker-compose.yaml. By default milvus will use local minio instead of external S3. 3. Run Milvus Run the following command to start Milvus that uses the S3 configurations. Configurations only take effect after Milvus starts. See Start Milvus for more information. Configure S3 on K8s For Milvus clusters on K8s, you can configure S3 in the same command that starts Milvus. Alternatively, you can configure S3 using the values.yml file on the /charts/milvus path in the milvus-helm repository before you start Milvus. The following table lists the keys for configuring S3 in the YAML file. Key Description Value minio.enabled Enables or disables MinIO. true / false externalS3.enabled Enables or disables S3. true / false externalS3.host The endpoint to access S3. externalS3.port The port to access S3. externalS3.rootPath The root path of the S3 storage. An emtpy string by default. externalS3.accessKey The access key ID for S3. externalS3.secretKey The secret access key for S3. externalS3.bucketName The name of the S3 bucket. externalS3.useSSL Whether to use SSL when connecting The values defaults to false Using the YAML file Configure the minio section in the values.yaml file. Configure the externalS3 section using your values in the values.yaml file. After configuring the preceding sections and saving the values.yaml file, run the following command to install Milvus that uses the S3 configurations. Using a command To install Milvus and configure S3, run the following command using your values. What's next Learn how to configure other Milvus dependencies with Docker Compose or Helm: Configure Meta Storage with Docker Compose or Helm Configure Message Storage with Docker Compose or Helm Edit this page Report a bug Request doc changes On this page Configure Object Storage with Docker Compose or HelmConfigure S3 with Docker ComposeConfigure S3 on K8sWhat's next Resources Docs Blog Managed service Tutorials Bootcamp Demo Video Tools Attu Milvus CLI Sizing Tool Milvus backup tool Community Get involved Discord GitHub Milvus. 2024 All rights reserved.\n",
      "{'h1': 'Terminology', 'h2': 'AutoID', 'h3': 'Auto Index', 'source': 'https://milvus.io/docs/glossary.md', 'doc_index': '605aa699-ac58-4874-9cc5-5ba3407aa206'}\n"
     ]
    }
   ],
   "source": [
    "print(len(html_docs), type(html_docs[0]))\n",
    "print(html_docs[65].page_content)\n",
    "print(html_docs[65].metadata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "961af854",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Inspect chunk lengths\n",
    "plot_chunk_lengths(html_docs, 'HTML')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "81105875",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "docs: 66, split into 1047 html sub chunks.\n"
     ]
    }
   ],
   "source": [
    "# Split html chunks into child chunks\n",
    "html_sub_docs = child_splitter.split_documents(html_docs)\n",
    "print(f\"docs: {len(html_docs)}, split into {len(html_sub_docs)} html sub chunks.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "53e51d07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Inspect chunk lengths\n",
    "plot_chunk_lengths(html_sub_docs, 'HTML Recursive Character')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "7b988783",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indexed a total of 1047 child documents in 1.92 seconds\n"
     ]
    }
   ],
   "source": [
    "# Drop the existing vectorstore if it exists.\n",
    "try:\n",
    "    del vectorstore\n",
    "except:\n",
    "    pass\n",
    "\n",
    "# Create vectorstore for vector index and retrieval.\n",
    "COLLECTION_NAME = \"MilvusDocs\"\n",
    "\n",
    "# Create vectorstore for vector index and retrieval.\n",
    "vectorstore = Milvus(\n",
    "    collection_name=COLLECTION_NAME,\n",
    "    embedding_function=embed_model,\n",
    "    connection_args={\"uri\": \"./milvus_demo.db\"},\n",
    "    auto_id=True,\n",
    "    # Set to True to drop the existing collection if it exists.\n",
    "    drop_old=True,\n",
    "    index_params = {\n",
    "        \"metric_type\": \"COSINE\",\n",
    "        \"index_type\": \"AUTOINDEX\",\n",
    "        \"params\": {},}\n",
    ")\n",
    "\n",
    "# Index the documents in the vector store.\n",
    "batch_size = 600\n",
    "total_docs = len(html_sub_docs)\n",
    "\n",
    "# Calculate the number of batches needed\n",
    "batches = (total_docs + batch_size - 1) // batch_size\n",
    "start_time = time.time()\n",
    "for i in range(batches):\n",
    "    batch_start = i * batch_size\n",
    "    batch_end = min(batch_start + batch_size, total_docs)\n",
    "    batch = sub_docs[batch_start:batch_end]\n",
    "    vectorstore.add_documents(batch)\n",
    "\n",
    "end_time = time.time()\n",
    "print(f\"Indexed a total of {total_docs} child documents in {time.time()-start_time:.2f} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84876dfa",
   "metadata": {},
   "source": [
    "#### Test with questions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "1e5a3c65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question: What is the default AUTOINDEX index and vector field distance metric in Milvus?\n",
      "Result #1, len: 510\n",
      "chunk: is set to True, and auto_id is enabled for the primary key. Additionally, a vector field is introduced, configured with a dimensionality of 768, along with the inclusion of four scalar fields, each with its respective attributes. Step 2: Set up index parameters Index parameters dictate how Milvus organizes your data within a collection. You can tailor the indexing process for specific fields by adjusting their metric_type and index_type. For the vector field, you have the flexibility to select COSINE, L2,\n",
      "(\"metadata: {'source': 'https://milvus.io/docs/manage-collections.md', 'pk': \"\n",
      " '451033276201043058}')\n",
      "Result #2, len: 506\n",
      "chunk: walks you through the basic operations on creating and managing indexes on vector fields in a collection. Overview Leveraging the metadata stored in an index file, Milvus organizes your data in a specialized structure, facilitating rapid retrieval of requested information during searches or queries. Milvus provides several index types to sort field values for efficient similarity searches. It also offers three metric types: Cosine Similarity (COSINE), Euclidean Distance (L2), and Inner Product (IP) to\n",
      "(\"metadata: {'source': 'https://milvus.io/docs/index-vector-fields.md', 'pk': \"\n",
      " '451033276201043283}')\n",
      "sources: 2, ['https://milvus.io/docs/manage-collections.md', 'https://milvus.io/docs/index-vector-fields.md']\n"
     ]
    }
   ],
   "source": [
    "# SELECT A PARTICULAR QUESTION TO ASK.\n",
    "SAMPLE_QUESTION = QUESTION4\n",
    "\n",
    "# The vector store retrieves whichever chunks you indexed:\n",
    "TOP_K = 2\n",
    "child_results = vectorstore.similarity_search(\n",
    "    SAMPLE_QUESTION,\n",
    "    k=TOP_K)\n",
    "\n",
    "print(f\"Question: {SAMPLE_QUESTION}\")\n",
    "\n",
    "# Print the retrieved chunk and metadata.\n",
    "# Append each unique context and source to a list.\n",
    "contexts = []\n",
    "sources = []\n",
    "for i, child_result in enumerate(child_results):\n",
    "    context = child_result.page_content\n",
    "    print(f\"Result #{i+1}, len: {len(context)}\")\n",
    "    print(f\"chunk: {context}\")\n",
    "    pprint.pprint(f\"metadata: {child_result.metadata}\")\n",
    "    context = child_result.page_content\n",
    "    contexts.append(context)\n",
    "    source = child_result.metadata['source']\n",
    "    if source not in sources:\n",
    "        sources.append(source)\n",
    "\n",
    "print(f\"sources: {len(sources)}, {sources}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "410393e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length long text to summarize: 1017\n",
      "sources: https://milvus.io/docs/index-vector-fields.md https://milvus.io/docs/manage-collections.md\n"
     ]
    }
   ],
   "source": [
    "# Separate all the context together by space.\n",
    "contexts_combined = ' '.join(contexts)\n",
    "# Lance Martin, LangChain, says put best contexts at end.\n",
    "contexts_combined = ' '.join(reversed(contexts))\n",
    "\n",
    "print(f\"Length long text to summarize: {len(contexts_combined)}\")\n",
    "\n",
    "# Separate all the unique sources together by comma.\n",
    "source_combined = ' '.join(reversed(list(dict.fromkeys(sources))))\n",
    "print(f\"sources: {source_combined}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "a36a25bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete the Milvus collection and doc store.\n",
    "# del vectorstore, retriever, store"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20cf59f0",
   "metadata": {},
   "source": [
    "## Summarize the context using a LLM\n",
    "\n",
    "Using a small, open source LLM should be good enough for the summarization task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "cfd45c26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length prompt: 1202\n"
     ]
    }
   ],
   "source": [
    "# Define temperature for the LLM and random seed.\n",
    "TEMPERATURE = 0.1\n",
    "TOP_P = 0.9\n",
    "RANDOM_SEED = 415\n",
    "MAX_TOKENS = 512\n",
    "FREQUENCY_PENALTY = 2\n",
    "\n",
    "# Define a system prompt to use for summarization.\n",
    "SYSTEM_PROMPT = f\"\"\"First select the text that is relevant to the \n",
    "user's question.  Second, summarize the selected text so it is clear,\n",
    "easy to understand, and concise, in fewer than 10 sentences.\n",
    "Text: {contexts_combined}\n",
    "\"\"\"\n",
    "print(f\"Length prompt: {len(SYSTEM_PROMPT)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c66618c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(SYSTEM_PROMPT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "3eee4d7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MODEL:llama3:latest, FORMAT:gguf, PARAMETER_SIZE:8.0B, QUANTIZATION_LEVEL:Q4_0, \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# !python -m pip install ollama\n",
    "# !ollama pull llama3\n",
    "import ollama\n",
    "\n",
    "# Verify details which model you are running.\n",
    "ollama_llama3 = ollama.list()['models'][0]\n",
    "\n",
    "# Print the model details.\n",
    "keys = ['format', 'parameter_size', 'quantization_level']\n",
    "print(f\"MODEL:{ollama.list()['models'][0]['name']}\", end=\", \")\n",
    "for key in keys:\n",
    "    print(f\"{str.upper(key)}:{ollama.list()['models'][0]['details'].get(key, 'Key not found in dictionary')}\", end=\", \")\n",
    "print(end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "574da045",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer: According to my selected text:\n",
      "\n",
      "The default AUTOINDEX index uses Cosine Similarity (COSINE) as its distance metric. This means that when you create an auto-indexed collection, it will use COSINE by default for the similarity search operations.\n",
      "\n",
      "In summary: The default AUTOINDEX index in Milvus uses Cosine Similarity (COSINE) as its distance metric. \n",
      "\n",
      "\n",
      "ollama_llama3_time: 10.50 seconds\n"
     ]
    }
   ],
   "source": [
    "# Send the question to llama 3 chat.\n",
    "start_time = time.time()\n",
    "response = ollama.chat(\n",
    "    messages=[\n",
    "        {\"role\": \"system\", \"content\": SYSTEM_PROMPT,},\n",
    "        \n",
    "        {\"role\": \"user\", \"content\": f\"question: {SAMPLE_QUESTION}\",}\n",
    "    ],\n",
    "    model='llama3',\n",
    "    stream=False,\n",
    "    options={\"temperature\": TEMPERATURE, \"seed\": RANDOM_SEED,\n",
    "             \"top_p\": TOP_P, \n",
    "            #  \"max_tokens\": MAX_TOKENS,\n",
    "             \"frequency_penalty\": FREQUENCY_PENALTY}\n",
    ")\n",
    "ollama_llama3_time = time.time() - start_time\n",
    "\n",
    "# Print all answers in the response.\n",
    "semantic_summary = \"\"\n",
    "semantic_summary += response['message']['content'] + \" \"\n",
    "print(f\"Answer: {semantic_summary}\")\n",
    "print(\"\\n\")\n",
    "print(f\"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd6060ce",
   "metadata": {},
   "source": [
    "# Use an LLM to Generate a chat response to the user's question using the Retrieved Context.\n",
    "\n",
    "Many different generative LLMs exist these days.  Check out the lmsys [leaderboard](https://chat.lmsys.org/?leaderboard).\n",
    "\n",
    "In this notebook, we'll try these LLMs:\n",
    "- The newly released open-source Llama 3 from Meta.\n",
    "- The cheapest, paid model from Anthropic Claude3 Haiku.\n",
    "- The standard in its price cateogory, gpt-3.5-turbo, from Openai."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "47e5bd6a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length prompt: 1487\n"
     ]
    }
   ],
   "source": [
    "from langchain.prompts import PromptTemplate\n",
    "\n",
    "SYSTEM_PROMPT = f\"\"\"First, check if the provided Context is relevant to \n",
    "the user's question.  Second, only if the provided Context is strongly relevant, \n",
    "answer the question using the Context.  Otherwise, if the Context is not \n",
    "strongly relevant, answer the question without using the Context.  \n",
    "Be clear, concise, relevant.  Answer clearly, in fewer than 2 sentences.\n",
    "Grounding sources: {source_combined}\n",
    "Context: {contexts_combined}\n",
    "\"\"\"\n",
    "print(f\"Length prompt: {len(SYSTEM_PROMPT)}\")\n",
    "\n",
    "# Inspect the prompt.\n",
    "# pprint.pprint(SYSTEM_PROMPT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11fb35aa",
   "metadata": {},
   "source": [
    "### Try Meta Llama 3 with Ollama to generate a human-like chat response to the user's question\n",
    "\n",
    "Follow the instructions to install ollama and pull a model.<br>\n",
    "https://github.com/ollama/ollama\n",
    "\n",
    "View details about which models are supported by ollama. <br>\n",
    "https://ollama.com/library/llama3\n",
    "\n",
    "That page says `ollama run llama3` will by default pull the latest \"instruct\" model, which is fine-tuned for chat/dialogue use cases.\n",
    "\n",
    "The other kind of llama3 models are \"pre-trained\" base model. <br>\n",
    "Example: ollama run llama3:text ollama run llama3:70b-text\n",
    "\n",
    "**Format** `gguf` means the model runs on CPU.  gg = \"Georgi Gerganov\", creator of the C library model format ggml, which was recently changed to gguf.\n",
    "\n",
    "**Quantization** (think of it like vector compaction) can lead to higher throughput at the expense of lower accuracy.  For the curious, quantization meanings can be found on: <br>\n",
    "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGML/tree/main.  \n",
    "\n",
    "Below just listing the main quantization types.\n",
    "- **q4_0**: Original quant method, 4-bit.\n",
    "- **q4_k_m**: Uses Q6_K for half of the attention.wv and feed_forward.w2 tensors, else Q4_K\n",
    "- **q5_0**: Higher accuracy, higher resource usage and slower inference.\n",
    "- **q5_k_m**: Uses Q6_K for half of the attention.wv and feed_forward.w2 tensors, else Q5_K\n",
    "- **q 6_k**: Uses Q8_K for all tensors\n",
    "- **q8_0**: Almost indistinguishable from float16. High resource use and slow. Not recommended for most users."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "0edc67e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MODEL:llama3:latest, FORMAT:gguf, PARAMETER_SIZE:8.0B, QUANTIZATION_LEVEL:Q4_0, \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# !python -m pip install ollama\n",
    "# !ollama pull llama3\n",
    "import ollama\n",
    "\n",
    "# Verify details which model you are running.\n",
    "ollama_llama3 = ollama.list()['models'][0]\n",
    "\n",
    "# Print the model details.\n",
    "keys = ['format', 'parameter_size', 'quantization_level']\n",
    "print(f\"MODEL:{ollama.list()['models'][0]['name']}\", end=\", \")\n",
    "for key in keys:\n",
    "    print(f\"{str.upper(key)}:{ollama.list()['models'][0]['details'].get(key, 'Key not found in dictionary')}\", end=\", \")\n",
    "print(end=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "394f31d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "According to your provided Context on creating and managing indexes on vector fields in a collection using Milvus, I can answer that:\n",
      "\n",
      "The default AUTOINDEX index uses Cosine Similarity (COSINE) as its distance metric.\n",
      "ollama_llama3_time: 2.66 seconds\n"
     ]
    }
   ],
   "source": [
    "# Send the question to llama 3 chat.\n",
    "start_time = time.time()\n",
    "response = ollama.chat(\n",
    "    messages=[\n",
    "        {\"role\": \"system\", \"content\": SYSTEM_PROMPT,},\n",
    "        \n",
    "        {\"role\": \"user\", \"content\": f\"question: {SAMPLE_QUESTION}\",}\n",
    "    ],\n",
    "    model='llama3',\n",
    "    stream=False,\n",
    "    options={\"temperature\": TEMPERATURE, \"seed\": RANDOM_SEED,\n",
    "             \"top_p\": TOP_P, \n",
    "            #  \"max_tokens\": MAX_TOKENS,\n",
    "             \"frequency_penalty\": FREQUENCY_PENALTY}\n",
    ")\n",
    "\n",
    "ollama_llama3_time = time.time() - start_time\n",
    "print(response['message']['content'])\n",
    "print(f\"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1f36f39",
   "metadata": {},
   "source": [
    "#### Call the LLM using a LangChain rag_chain pipeline."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "fc549f2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer: Based on the provided Context, the default AUTOINDEX index and vector field distance metric in Milvus are:\n",
      "\n",
      "* Index type: Not specified (since auto_id is enabled), but it will be set to COSINE or L2 based on the metric_type.\n",
      "* Distance metric: Not specified (since no specific metric_type is given). However, considering the provided Context includes a vector field with dimensionality 768 and scalar fields, it's likely that the default distance metric would be COSINE Similarity (COSINE) for the vector field.\n",
      "Sources: ['https://milvus.io/docs/manage-collections.md', 'https://milvus.io/docs/index-vector-fields.md', 'https://milvus.io/docs/index.md']\n",
      "ollama_llama3_time: 5.76 seconds\n"
     ]
    }
   ],
   "source": [
    "# Change the LangChain llm to the llama3 model with Ollama.\n",
    "from langchain_community.chat_models import ChatOllama\n",
    "LLM_NAME = 'llama3'\n",
    "llm=ChatOllama(model=LLM_NAME)\n",
    "\n",
    "# Child doc, Recursive Text Splitter, or HTML context RAG chain.\n",
    "start_time = time.time()\n",
    "execute_rag_chain(vectorstore.as_retriever(), llm, SAMPLE_QUESTION)\n",
    "ollama_llama3_time = time.time() - start_time\n",
    "print(f\"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds\")\n",
    "\n",
    "# # Parent doc RAG chain.\n",
    "# start_time = time.time()\n",
    "# execute_rag_chain(retriever, llm, SAMPLE_QUESTION)\n",
    "# ollama_llama3_time = time.time() - start_time\n",
    "# print(f\"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds\")\n",
    "\n",
    "# # Semantic chunks RAG chain.\n",
    "# start_time = time.time()\n",
    "# semantic_retriever = vectorstore.as_retriever(search_kwargs={\"k\" : TOP_K})\n",
    "# execute_rag_chain(semantic_retriever.invoke, llm, SAMPLE_QUESTION)\n",
    "# ollama_llama3_time = time.time() - start_time\n",
    "# print(f\"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds\")\n",
    "\n",
    "# # ANSWER:\n",
    "# # The parameters for HNSW mentioned in the text are:\n",
    "# # * M: maximum number of outgoing connections in each layer, with a range of [1, 65535].\n",
    "# # * nlist: number of cluster units, with a range of [1, 65536].\n",
    "# # These parameters control the indexing process and affect the performance of the algorithm.\n",
    "\n",
    "# # Openai answer:\n",
    "# # Answer: The parameters for HNSW include M (maximum number of outgoing \n",
    "# # connections), efConstruction (search range during index building), \n",
    "# # and ef (search range when searching targets). The values for these \n",
    "# # parameters can be specified within certain ranges to optimize performance.\n",
    "# # Sources: ['https://milvus.io/docs/index.md']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf12b360",
   "metadata": {},
   "source": [
    "# Now try Anyscale endpoints\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "59f95f52",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # List all the anyscale endpoint models.\n",
    "# !llm models list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "1ef7529f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('According to the provided Context, Milvus uses Cosine Similarity (COSINE) as '\n",
      " 'the default distance metric for vector fields.')\n",
      "llama3_anyscale_endpoints_time: 1.83 seconds\n"
     ]
    }
   ],
   "source": [
    "# Call Anyscale enpoint using OpenAI API.\n",
    "import openai\n",
    "\n",
    "LLM_NAME = \"meta-llama/Llama-3-8b-chat-hf\"\n",
    "\n",
    "# 1. Get your API key: https://platform.openai.com/api-keys\n",
    "# 2. Save your api key in env variable.\n",
    "# https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n",
    "anyscale_client = openai.OpenAI(\n",
    "    base_url = \"https://api.endpoints.anyscale.com/v1\",\n",
    "    api_key=os.environ.get(\"ANYSCALE_ENPOINT_KEY\"),\n",
    ")\n",
    "\n",
    "# 3. Generate response using the OpenAI API.\n",
    "start_time = time.time()\n",
    "response = anyscale_client.chat.completions.create(\n",
    "    messages=[\n",
    "        {\"role\": \"system\", \"content\": SYSTEM_PROMPT,},\n",
    "        {\"role\": \"user\", \"content\": f\"question: {SAMPLE_QUESTION}\",}\n",
    "    ],\n",
    "    model=LLM_NAME,\n",
    "    temperature=TEMPERATURE,\n",
    "    seed=RANDOM_SEED,\n",
    "    frequency_penalty=FREQUENCY_PENALTY,\n",
    "    top_p=TOP_P, \n",
    "    max_tokens=MAX_TOKENS,\n",
    ")\n",
    "llama3_anyscale_endpoints_time = time.time() - start_time\n",
    "\n",
    "# Print the response.\n",
    "pprint.pprint(response.choices[0].message.content.replace('\\n', ' '))\n",
    "print(f\"llama3_anyscale_endpoints_time: {format(llama3_anyscale_endpoints_time, '.2f')} seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "309d7025",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('According to the provided Context, Milvus uses Cosine Similarity (COSINE) as '\n",
      " 'the default distance metric for vector fields.')\n",
      "llama3_octai_endpoints_time: 0.92 seconds\n"
     ]
    }
   ],
   "source": [
    "# Also try OctoAI\n",
    "# !python -m pip install octoai\n",
    "from octoai.text_gen import ChatMessage\n",
    "from octoai.client import OctoAI\n",
    "\n",
    "LLM_NAME = \"meta-llama-3-8b-instruct\"\n",
    "\n",
    "octoai_client = OctoAI(\n",
    "    api_key=os.environ.get(\"OCTOAI_TOKEN\"),\n",
    ")\n",
    "\n",
    "# Generate response using OpenAI API.\n",
    "start_time = time.time()\n",
    "response = octoai_client.text_gen.create_chat_completion(\n",
    "\tmessages=[\n",
    "\t\tChatMessage(\n",
    "\t\t\tcontent=SYSTEM_PROMPT,\n",
    "\t\t\trole=\"system\"\n",
    "\t\t),\n",
    "\t\tChatMessage(\n",
    "\t\t\tcontent=SAMPLE_QUESTION,\n",
    "\t\t\trole=\"user\"\n",
    "\t\t)\n",
    "\t],\n",
    "\tmodel=LLM_NAME,\n",
    "    temperature=TEMPERATURE,\n",
    "    # seed=RANDOM_SEED,\n",
    "    frequency_penalty=FREQUENCY_PENALTY,\n",
    "    top_p=TOP_P, \n",
    "    max_tokens=MAX_TOKENS,\n",
    ")\n",
    "llama3_octai_endpoints_time = time.time() - start_time\n",
    "\n",
    "# Print the response.\n",
    "pprint.pprint(response.choices[0].message.content.replace('\\n', ' '))\n",
    "print(f\"llama3_octai_endpoints_time: {format(llama3_octai_endpoints_time, '.2f')} seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "e6b94795",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('The default AUTOINDEX index in Milvus is L2 (Euclidean Distance) and the '\n",
      " 'default distance metric for vector fields is COSINE.')\n",
      "llama3_groq_endpoints_time: 0.52 seconds\n"
     ]
    }
   ],
   "source": [
    "# Also try Groq endpoints\n",
    "# !python -m pip install groq\n",
    "from groq import Groq\n",
    "\n",
    "LLM_NAME = \"llama3-8b-8192\"\n",
    "\n",
    "groq_client = Groq(\n",
    "    api_key=os.environ.get(\"GROQ_API_KEY\"),\n",
    ")\n",
    "\n",
    "# Generate response using OpenAI API.\n",
    "start_time = time.time()\n",
    "response = groq_client.chat.completions.create(\n",
    "    messages=[\n",
    "        {\"role\": \"system\", \"content\": SYSTEM_PROMPT,},\n",
    "        {\"role\": \"user\", \"content\": f\"question: {SAMPLE_QUESTION}\",}\n",
    "    ],\n",
    "    model=LLM_NAME,\n",
    "    temperature=TEMPERATURE,\n",
    "    seed=RANDOM_SEED,\n",
    "    frequency_penalty=FREQUENCY_PENALTY,\n",
    "    top_p=TOP_P, \n",
    "    max_tokens=MAX_TOKENS,\n",
    ")\n",
    "llama3_groq_endpoints_time = time.time() - start_time\n",
    "\n",
    "# Print the response.\n",
    "pprint.pprint(response.choices[0].message.content.replace('\\n', ' '))\n",
    "print(f\"llama3_groq_endpoints_time: {format(llama3_groq_endpoints_time, '.2f')} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fd2b2dd",
   "metadata": {},
   "source": [
    "## Also try Anthropic Claude3 \n",
    "\n",
    "We've practiced retrieval for free on our own data using open-source LLMs.  <br>\n",
    "\n",
    "Now let's make a call to the paid Claude3. [List of models](https://docs.anthropic.com/claude/docs/models-overview)\n",
    "- Opus - most expensive\n",
    "- Sonnet\n",
    "- Haiku - least expensive!\n",
    "\n",
    "Prompt engineering tutorials\n",
    "- [Interactive](https://docs.google.com/spreadsheets/d/19jzLgRruG9kjUQNKtCg1ZjdD6l6weA6qRXG5zLIAhC8/edit#gid=150872633)\n",
    "- [Static](https://docs.google.com/spreadsheets/d/1jIxjzUWG-6xBVIa2ay6yDpLyeuOh_hR_ZB75a47KX_E/edit#gid=869808629)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "edf66e04",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SYSTEM_PROMPT = f\"\"\"Use the Context below to answer the user's question. \n",
    "# Be clear, factual, complete, concise.\n",
    "# If the answer is not in the Context, say \"I don't know\". \n",
    "# Otherwise answer with fewer than 4 sentences and cite the unique sources.\n",
    "# Context: {contexts_combined}\n",
    "# Sources: {source_combined}\n",
    "\n",
    "# Answer with 2 parts: the answer and the source citations.\n",
    "# Answer: The answer to the question.\n",
    "# Sources: unique url sources\n",
    "# \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "c87b8428",
   "metadata": {},
   "outputs": [],
   "source": [
    "# # !python -m pip install anthropic\n",
    "# import anthropic\n",
    "\n",
    "# ANTHROPIC_API_KEY=os.environ.get(\"ANTHROPIC_API_KEY\")\n",
    "\n",
    "# # # Model names\n",
    "# # claude-3-opus-20240229\n",
    "# # claude-3-sonnet-20240229\n",
    "# # claude-3-haiku-20240307\n",
    "# CLAUDE_MODEL = \"claude-3-haiku-20240307\"\n",
    "# print(f\"Model: {CLAUDE_MODEL}\")\n",
    "# print()\n",
    "\n",
    "# client = anthropic.Anthropic(\n",
    "#     # defaults to os.environ.get(\"ANTHROPIC_API_KEY\")\n",
    "#     api_key=ANTHROPIC_API_KEY,\n",
    "# )\n",
    "\n",
    "# # Print the question and answer along with grounding sources and citations.\n",
    "# print(f\"Question: {SAMPLE_QUESTION}\")\n",
    "\n",
    "# # CAREFUL!! THIS COSTS MONEY!!\n",
    "# message = client.messages.create(\n",
    "#     model=CLAUDE_MODEL,\n",
    "#     max_tokens=1000,\n",
    "#     temperature=0.0,\n",
    "#     system=SYSTEM_PROMPT,\n",
    "#     messages=[\n",
    "#         {\"role\": \"user\", \"content\": SAMPLE_QUESTION}\n",
    "#     ]\n",
    "# )\n",
    "# print(\"Answer:\")\n",
    "# pprint.pprint(message.content[0].text.replace('\\n', ' '))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8193430b",
   "metadata": {},
   "source": [
    "<div>\n",
    "<img src=\"../../../images/anthropic_claude3.png\" width=\"80%\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1facf70",
   "metadata": {},
   "source": [
    "## Also try MistralAI's Mixtral 8x7B-Instruct-v0.1\n",
    "\n",
    "This time ollama's version requires 48GB RAM. If you have big enough compute, run the command:\n",
    "> ollama run mixtral\n",
    "\n",
    "Since my laptop is a M2 with only 16GB RAM, I decided to **run Mixtral using Anyscale Endpoints**. Instructions to install. <br>\n",
    "> https://github.com/simonw/llm-anyscale-endpoints\n",
    "\n",
    "To get back to **Anyscale Endpoints** anytime, open the playground.<br>\n",
    "https://console.anyscale.com/v2/playground"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "e6b16264",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(' The default AUTOINDEX index in Milvus is based on the HNSW (Hierarchical '\n",
      " 'Navigable Small World) algorithm, and the default vector field distance '\n",
      " 'metric is Euclidean Distance (L2).')\n",
      "mixtral_anyscale_endpoints_time: 2.21 seconds\n"
     ]
    }
   ],
   "source": [
    "# Call Anyscale enpoint using OpenAI API.\n",
    "import openai\n",
    "\n",
    "LLM_NAME = \"mistralai/Mixtral-8x7B-Instruct-v0.1\"\n",
    "\n",
    "# 2. Get your API key: https://platform.openai.com/api-keys\n",
    "# 3. Save your api key in env variable.\n",
    "# https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n",
    "openai_client = openai.OpenAI(\n",
    "    base_url = \"https://api.endpoints.anyscale.com/v1\",\n",
    "    api_key=os.environ.get(\"ANYSCALE_ENPOINT_KEY\"),\n",
    ")\n",
    "\n",
    "# 4. Generate response using the OpenAI API.\n",
    "start_time = time.time()\n",
    "response = openai_client.chat.completions.create(\n",
    "    messages=[\n",
    "        {\"role\": \"system\", \"content\": SYSTEM_PROMPT,},\n",
    "        {\"role\": \"user\", \"content\": f\"question: {SAMPLE_QUESTION}\",}\n",
    "    ],\n",
    "    model=LLM_NAME,\n",
    "    temperature=TEMPERATURE,\n",
    "    seed=RANDOM_SEED,\n",
    "    frequency_penalty=FREQUENCY_PENALTY,\n",
    ")\n",
    "mixtral_anyscale_endpoints_time = time.time() - start_time\n",
    "\n",
    "# Print the response.\n",
    "pprint.pprint(response.choices[0].message.content.replace('\\n', ' '))\n",
    "print(f\"mixtral_anyscale_endpoints_time: {format(mixtral_anyscale_endpoints_time, '.2f')} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecc532a8",
   "metadata": {},
   "source": [
    "<div>\n",
    "<img src=\"../../../images/mistral_mixtral.png\" width=\"80%\"/>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e172726",
   "metadata": {},
   "source": [
    "## Also try OpenAI\n",
    "\n",
    "💡 Note: For use cases that need to always be factually grounded, use very low temperature values while more creative tasks can benefit from higher temperatures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "493c5e82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length prompt: 1538\n"
     ]
    }
   ],
   "source": [
    "SYSTEM_PROMPT = f\"\"\"First, check if the provided Context is relevant to \n",
    "the user's question.  Second, only if the provided Context is strongly relevant, \n",
    "answer the question using the Context.  Otherwise, if the Context is not \n",
    "strongly relevant, answer the question without using the Context.\n",
    "Be clear, concise, relevant.  Answer clearly, easy to understand, \n",
    "fewer than 2 sentences, and cite unique grounding sources.\n",
    "Grounding sources: {source_combined}\n",
    "Context: {contexts_combined}\n",
    "\"\"\"\n",
    "print(f\"Length prompt: {len(SYSTEM_PROMPT)}\")\n",
    "\n",
    "# Inspect the prompt.\n",
    "# pprint.pprint(SYSTEM_PROMPT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "76a62feb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question: What is the default AUTOINDEX index and vector field distance metric in Milvus?\n",
      "('Answer: The default AUTOINDEX index in Milvus is IVF_SQ8, and the default '\n",
      " 'vector field distance metric is Inner Product (IP).')\n",
      "\n",
      "\n",
      "chatgpt_3.5_turbo_time: 0.94234\n"
     ]
    }
   ],
   "source": [
    "import openai, pprint\n",
    "from openai import OpenAI\n",
    "\n",
    "# 1. Define the generation llm model to use.\n",
    "# https://openai.com/blog/new-embedding-models-and-api-updates\n",
    "# Customers using the pinned gpt-3.5-turbo model alias will be automatically upgraded to gpt-3.5-turbo-0125 two weeks after this model launches.\n",
    "LLM_NAME = \"gpt-3.5-turbo\"\n",
    "\n",
    "# 2. Get your API key: https://platform.openai.com/api-keys\n",
    "# 3. Save your api key in env variable.\n",
    "# https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n",
    "openai_client = OpenAI(\n",
    "    # This is the default and can be omitted\n",
    "    api_key=os.environ.get(\"OPENAI_API_KEY\"),\n",
    ")\n",
    "\n",
    "# 4. Generate response using the OpenAI API.\n",
    "start_time = time.time()\n",
    "response = openai_client.chat.completions.create(\n",
    "    messages=[\n",
    "        {\"role\": \"system\", \"content\": SYSTEM_PROMPT,},\n",
    "        {\"role\": \"user\", \"content\": f\"question: {SAMPLE_QUESTION}\",}\n",
    "    ],\n",
    "    model=LLM_NAME,\n",
    "    temperature=TEMPERATURE,\n",
    "    seed=RANDOM_SEED,\n",
    "    frequency_penalty=FREQUENCY_PENALTY,\n",
    ")\n",
    "chatgpt_35turbo_time = time.time() - start_time\n",
    "\n",
    "# Print the question and answer along with grounding sources and citations.\n",
    "print(f\"Question: {SAMPLE_QUESTION}\")\n",
    "\n",
    "# 5. Print all answers in the response.\n",
    "for i, choice in enumerate(response.choices, 1):\n",
    "    pprint.pprint(f\"Answer: {choice.message.content}\")\n",
    "    print(\"\\n\")\n",
    "print(f\"chatgpt_3.5_turbo_time: {format(chatgpt_35turbo_time, '.5f')}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb8aeeba",
   "metadata": {},
   "source": [
    "## Use Ragas to evaluate RAG pipeline\n",
    "\n",
    "Ragas is an open source project for evaluating RAG components.  [Paper](https://arxiv.org/abs/2309.15217), [Code](https://docs.ragas.io/en/stable/getstarted/index.html), [Docs](https://docs.ragas.io/en/stable/getstarted/index.html), [Intro blog](https://medium.com/towards-data-science/rag-evaluation-using-ragas-4645a4c6c477).\n",
    "\n",
    "<div>\n",
    "<img src=\"../../../images/ragas_eval_image.png\" width=\"80%\"/>\n",
    "</div>\n",
    "\n",
    "**Please note that RAGAS can use a large amount of OpenAI api token consumption.** <br> \n",
    "\n",
    "Read through this notebook carefully and pay attention to the number of questions and metrics you want to evaluate.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "5d0c2299",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !python -m pip install -U ragas dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "e1097990",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Question</th>\n",
       "      <th>ground_truth_answer</th>\n",
       "      <th>recursive_context_512_k_2</th>\n",
       "      <th>html_context_512_k_2</th>\n",
       "      <th>parent_context_1536_k1</th>\n",
       "      <th>semantic_context_k_1</th>\n",
       "      <th>semantic_context_k_2_summary</th>\n",
       "      <th>parent_context_1536_k1_text-embedding-3-small</th>\n",
       "      <th>Custom_RAG_answer</th>\n",
       "      <th>llama3_ollama_answer</th>\n",
       "      <th>llama3_anyscale_answer</th>\n",
       "      <th>llama3_octoai_answer</th>\n",
       "      <th>llama3_groq_answer</th>\n",
       "      <th>mixtral_8x7b_anyscale_answer</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>What do the parameters for HNSW mean?</td>\n",
       "      <td>* M: maximum degree, or number of connections ...</td>\n",
       "      <td>node closest to the target in this layer, and ...</td>\n",
       "      <td>layer, finds the node closest to the target in...</td>\n",
       "      <td>Parameter Description Range Default value npro...</td>\n",
       "      <td>Index building parameters Parameter Descriptio...</td>\n",
       "      <td>* `M`: The maximum number of outgoing connecti...</td>\n",
       "      <td>Parameter Description Range Default value npro...</td>\n",
       "      <td>The parameters for HNSW (Hierarchical Navigabl...</td>\n",
       "      <td>* `M`: Maximum number of outgoing connections ...</td>\n",
       "      <td>* M: Maximum number of outgoing connections in...</td>\n",
       "      <td>* `M`: Maximum number of outgoing connections ...</td>\n",
       "      <td>* M: Maximum number of outgoing connections in...</td>\n",
       "      <td>The parameters for HNSW, a graph-based indexin...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>What are good default values for HNSW paramete...</td>\n",
       "      <td>M=16, efConstruction=32,  ef=32</td>\n",
       "      <td>Select your Milvus distribution first. Index b...</td>\n",
       "      <td>you can set the top-K up to 8192 for any searc...</td>\n",
       "      <td>Select your Milvus distribution first. Index b...</td>\n",
       "      <td>Index building parameters Parameter Descriptio...</td>\n",
       "      <td>* `nlist`: This parameter controls the number ...</td>\n",
       "      <td>Parameter Description Range Default value npro...</td>\n",
       "      <td>* M=48  * efConstruction=200</td>\n",
       "      <td>* For `nprobe`, a reasonable default value is ...</td>\n",
       "      <td>* nprobe: around 10-20  * reorder_k: top_k (de...</td>\n",
       "      <td>* nprobe: [1-25]  * reorder_k: top_k (not spec...</td>\n",
       "      <td>* nprobe: 16  * reorder_k: 128  * M: 128  * ef...</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>What does nlist vs nprobe mean in ivf_flat?</td>\n",
       "      <td># nlist:  controls how the vector data is part...</td>\n",
       "      <td>FAQ What is the difference between FLAT index ...</td>\n",
       "      <td>performance can be improved with minimal impac...</td>\n",
       "      <td>FAQ What is the difference between FLAT index ...</td>\n",
       "      <td>See Supported Metrics. IVF_FLAT IVF_FLAT divid...</td>\n",
       "      <td>**nlist (Number of List)**:\\nThis parameter de...</td>\n",
       "      <td>1] FAQ What is the difference between FLAT ind...</td>\n",
       "      <td>- nlist refers to the number of clusters into ...</td>\n",
       "      <td>- `nlist` refers to the number of clusters (or...</td>\n",
       "      <td>- `nlist` refers to the number of clusters tha...</td>\n",
       "      <td>- `nlist` refers to the number of clusters tha...</td>\n",
       "      <td>- `nlist` refers to the number of clusters to ...</td>\n",
       "      <td>- `nlist` refers to the number of clusters in ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>What is the default AUTOINDEX index and vector...</td>\n",
       "      <td>Index type = HNSW and distance metric=IP Inner...</td>\n",
       "      <td>True, and auto_id is enabled for the primary k...</td>\n",
       "      <td>is set to True, and auto_id is enabled for the...</td>\n",
       "      <td>vector in the data to be inserted, are treated...</td>\n",
       "      <td>For a detailed explanation of the schema, refe...</td>\n",
       "      <td>According to the provided text, when creating ...</td>\n",
       "      <td>vector in the data to be inserted, are treated...</td>\n",
       "      <td>The default AUTOINDEX index in Milvus is IVF_S...</td>\n",
       "      <td>The default `AUTOINDEX` index type uses L2 (Eu...</td>\n",
       "      <td>The default distance metric for vector fields ...</td>\n",
       "      <td>Milvus uses COSINE as the default distance met...</td>\n",
       "      <td>The default distance metric for vector fields ...</td>\n",
       "      <td>The default distance metric for vector fields ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                            Question  \\\n",
       "0              What do the parameters for HNSW mean?   \n",
       "1  What are good default values for HNSW paramete...   \n",
       "2        What does nlist vs nprobe mean in ivf_flat?   \n",
       "3  What is the default AUTOINDEX index and vector...   \n",
       "\n",
       "                                 ground_truth_answer  \\\n",
       "0  * M: maximum degree, or number of connections ...   \n",
       "1                    M=16, efConstruction=32, \n",
       "ef=32   \n",
       "2  # nlist:  controls how the vector data is part...   \n",
       "3  Index type = HNSW and distance metric=IP Inner...   \n",
       "\n",
       "                           recursive_context_512_k_2  \\\n",
       "0  node closest to the target in this layer, and ...   \n",
       "1  Select your Milvus distribution first. Index b...   \n",
       "2  FAQ What is the difference between FLAT index ...   \n",
       "3  True, and auto_id is enabled for the primary k...   \n",
       "\n",
       "                                html_context_512_k_2  \\\n",
       "0  layer, finds the node closest to the target in...   \n",
       "1  you can set the top-K up to 8192 for any searc...   \n",
       "2  performance can be improved with minimal impac...   \n",
       "3  is set to True, and auto_id is enabled for the...   \n",
       "\n",
       "                              parent_context_1536_k1  \\\n",
       "0  Parameter Description Range Default value npro...   \n",
       "1  Select your Milvus distribution first. Index b...   \n",
       "2  FAQ What is the difference between FLAT index ...   \n",
       "3  vector in the data to be inserted, are treated...   \n",
       "\n",
       "                                semantic_context_k_1  \\\n",
       "0  Index building parameters Parameter Descriptio...   \n",
       "1  Index building parameters Parameter Descriptio...   \n",
       "2  See Supported Metrics. IVF_FLAT IVF_FLAT divid...   \n",
       "3  For a detailed explanation of the schema, refe...   \n",
       "\n",
       "                        semantic_context_k_2_summary  \\\n",
       "0  * `M`: The maximum number of outgoing connecti...   \n",
       "1  * `nlist`: This parameter controls the number ...   \n",
       "2  **nlist (Number of List)**:\\nThis parameter de...   \n",
       "3  According to the provided text, when creating ...   \n",
       "\n",
       "       parent_context_1536_k1_text-embedding-3-small  \\\n",
       "0  Parameter Description Range Default value npro...   \n",
       "1  Parameter Description Range Default value npro...   \n",
       "2  1] FAQ What is the difference between FLAT ind...   \n",
       "3  vector in the data to be inserted, are treated...   \n",
       "\n",
       "                                   Custom_RAG_answer  \\\n",
       "0  The parameters for HNSW (Hierarchical Navigabl...   \n",
       "1                       * M=48 \n",
       "* efConstruction=200   \n",
       "2  - nlist refers to the number of clusters into ...   \n",
       "3  The default AUTOINDEX index in Milvus is IVF_S...   \n",
       "\n",
       "                                llama3_ollama_answer  \\\n",
       "0  * `M`: Maximum number of outgoing connections ...   \n",
       "1  * For `nprobe`, a reasonable default value is ...   \n",
       "2  - `nlist` refers to the number of clusters (or...   \n",
       "3  The default `AUTOINDEX` index type uses L2 (Eu...   \n",
       "\n",
       "                              llama3_anyscale_answer  \\\n",
       "0  * M: Maximum number of outgoing connections in...   \n",
       "1  * nprobe: around 10-20 \n",
       "* reorder_k: top_k (de...   \n",
       "2  - `nlist` refers to the number of clusters tha...   \n",
       "3  The default distance metric for vector fields ...   \n",
       "\n",
       "                                llama3_octoai_answer  \\\n",
       "0  * `M`: Maximum number of outgoing connections ...   \n",
       "1  * nprobe: [1-25] \n",
       "* reorder_k: top_k (not spec...   \n",
       "2  - `nlist` refers to the number of clusters tha...   \n",
       "3  Milvus uses COSINE as the default distance met...   \n",
       "\n",
       "                                  llama3_groq_answer  \\\n",
       "0  * M: Maximum number of outgoing connections in...   \n",
       "1  * nprobe: 16 \n",
       "* reorder_k: 128 \n",
       "* M: 128 \n",
       "* ef...   \n",
       "2  - `nlist` refers to the number of clusters to ...   \n",
       "3  The default distance metric for vector fields ...   \n",
       "\n",
       "                        mixtral_8x7b_anyscale_answer  \n",
       "0  The parameters for HNSW, a graph-based indexin...  \n",
       "1                                                NaN  \n",
       "2  - `nlist` refers to the number of clusters in ...  \n",
       "3  The default distance metric for vector fields ...  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os, sys, pprint\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import ragas, datasets\n",
    "\n",
    "# Libraries to customize ragas critic model.\n",
    "from ragas.llms import LangchainLLMWrapper\n",
    "from langchain_community.chat_models import ChatOllama\n",
    "\n",
    "# Libraries to customize ragas embedding model.\n",
    "from langchain_huggingface import HuggingFaceEmbeddings\n",
    "from ragas.embeddings import LangchainEmbeddingsWrapper\n",
    "\n",
    "# Import custom functions for evaluation.\n",
    "sys.path.append(\"../../Evaluation\")\n",
    "import eval_ragas as _eval_ragas\n",
    "\n",
    "# Import the evaluation metrics.\n",
    "from ragas.metrics import (\n",
    "    context_recall, \n",
    "    context_precision, \n",
    "    faithfulness, \n",
    "    answer_relevancy, \n",
    "    answer_similarity,\n",
    "    answer_correctness\n",
    "    )\n",
    "\n",
    "# Get the current working directory.\n",
    "cwd = os.getcwd()\n",
    "relative_path = '/../../Evaluation/data/blog_eval_answers.csv'\n",
    "file_path = cwd + relative_path\n",
    "# print(f\"file_path: {file_path}\")\n",
    "\n",
    "# Read ground truth answers from a CSV file.\n",
    "eval_df = pd.read_csv(file_path, header=0, skip_blank_lines=True)\n",
    "display(eval_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "8ae8d2b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/miniconda3/envs/py311-unum/lib/python3.11/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating CONTEXTS using 4 eval questions:\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "61894181a9d042478773156e8897007e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Evaluating:   0%|          | 0/8 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluate chunking: recursive_context_512_k_2, avg_score: 0.67\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e5edaa6713cb4a9394db97b96123daf9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Evaluating:   0%|          | 0/8 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluate chunking: html_context_512_k_2, avg_score: 0.77\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed1cb53bbeab430f9edbc2375dface6b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Evaluating:   0%|          | 0/8 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluate chunking: parent_context_1536_k1, avg_score: 0.7\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fcf15753d2914075b51a0d5d134a34d3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Evaluating:   0%|          | 0/8 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Failed to parse output. Returning None.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluate chunking: semantic_context_k_1, avg_score: 0.37\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aa587321b465400bbe1c1618dc07af07",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Evaluating:   0%|          | 0/8 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluate chunking: semantic_context_k_2_summary, avg_score: 0.5\n"
     ]
    }
   ],
   "source": [
    "##########################################\n",
    "# Set the evaluation type.\n",
    "EVALUATE_WHAT = 'ANSWERS' \n",
    "EVALUATE_WHAT = 'CONTEXTS'\n",
    "##########################################\n",
    "\n",
    "# Set the columns to evaluate.\n",
    "if EVALUATE_WHAT == 'CONTEXTS':\n",
    "    cols_to_evaluate=\\\n",
    "    ['recursive_context_512_k_2', 'html_context_512_k_2', 'parent_context_1536_k1',\n",
    "     'semantic_context_k_1', 'semantic_context_k_2_summary']\n",
    "    # cols_to_evaluate=\\\n",
    "    # ['parent_context_1536_k1', 'parent_context_1536_k1_text-embedding-3-small']\n",
    "elif EVALUATE_WHAT == 'ANSWERS':\n",
    "    cols_to_evaluate=['Custom_RAG_answer', 'llama3_ollama_answer', \n",
    "                      'llama3_anyscale_answer', 'llama3_octoai_answer',\n",
    "                      'llama3_groq_answer', 'mixtral_8x7b_anyscale_answer']\n",
    "\n",
    "# Set the metrics to evaluate.\n",
    "if EVALUATE_WHAT == 'ANSWERS':\n",
    "    eval_metrics=[\n",
    "        answer_relevancy,\n",
    "        answer_similarity,\n",
    "        answer_correctness,\n",
    "        faithfulness,\n",
    "        ]\n",
    "    metrics = ['answer_relevancy', 'answer_similarity', 'answer_correctness', 'faithfulness']\n",
    "elif EVALUATE_WHAT == 'CONTEXTS':\n",
    "    eval_metrics=[\n",
    "        context_recall, \n",
    "        context_precision,\n",
    "        ]\n",
    "    metrics = ['context_recall', 'context_precision']\n",
    "    \n",
    "# Change the default llm-as-critic model to gpt-3.5-turbo.\n",
    "# LLM_NAME = \"gpt-3.5-turbo\" #OpenAI\n",
    "# ragas_llm = ragas.llms.llm_factory(model=LLM_NAME)\n",
    "\n",
    "# Change the default the llm-as-critic model to local llama3.\n",
    "LLM_NAME = 'llama3'\n",
    "ragas_llm = LangchainLLMWrapper(langchain_llm=ChatOllama(model=LLM_NAME))\n",
    "\n",
    "# Change the default embeddings models to use model on HuggingFace.\n",
    "EMB_NAME = \"BAAI/bge-large-en-v1.5\"\n",
    "model_kwargs = {'device': 'cpu'}\n",
    "encode_kwargs = {'normalize_embeddings': True}\n",
    "lc_embed_model = HuggingFaceEmbeddings(\n",
    "    model_name=EMB_NAME,\n",
    "    model_kwargs=model_kwargs,\n",
    "    encode_kwargs=encode_kwargs\n",
    ")\n",
    "ragas_emb = LangchainEmbeddingsWrapper(embeddings=lc_embed_model)\n",
    "\n",
    "# Change embeddings and critic models for each metric.\n",
    "for metric in metrics:\n",
    "    globals()[metric].llm = ragas_llm\n",
    "    globals()[metric].embeddings = ragas_emb\n",
    "\n",
    "# Execute the evaluation.\n",
    "print(f\"Evaluating {EVALUATE_WHAT} using {eval_df.shape[0]} eval questions:\")\n",
    "ragas_result, scores = _eval_ragas.evaluate_ragas_model(\n",
    "    eval_df, \n",
    "    eval_metrics, \n",
    "    what_to_evaluate=EVALUATE_WHAT,\n",
    "    cols_to_evaluate=cols_to_evaluate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5bad9cd6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'recursive_context_512_k_2': 0.67},\n",
      " {'html_context_512_k_2': 0.77},\n",
      " {'parent_context_1536_k1': 0.7},\n",
      " {'semantic_context_k_1': 0.37},\n",
      " {'semantic_context_k_2_summary': 0.5}]\n",
      "Chunking 108.0% improvement.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>question</th>\n",
       "      <th>contexts</th>\n",
       "      <th>answer</th>\n",
       "      <th>ground_truth</th>\n",
       "      <th>context_recall</th>\n",
       "      <th>context_precision</th>\n",
       "      <th>context_f1</th>\n",
       "      <th>evaluated</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>What do the parameters for HNSW mean?</td>\n",
       "      <td>[node closest to the target in this layer, and...</td>\n",
       "      <td>The parameters for HNSW (Hierarchical Navigabl...</td>\n",
       "      <td>* M: maximum degree, or number of connections ...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>recursive_context_512_k_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>What are good default values for HNSW paramete...</td>\n",
       "      <td>[Select your Milvus distribution first. Index ...</td>\n",
       "      <td>* M=48  * efConstruction=200</td>\n",
       "      <td>M=16, efConstruction=32,  ef=32</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>recursive_context_512_k_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>What does nlist vs nprobe mean in ivf_flat?</td>\n",
       "      <td>[FAQ What is the difference between FLAT index...</td>\n",
       "      <td>- nlist refers to the number of clusters into ...</td>\n",
       "      <td># nlist:  controls how the vector data is part...</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>recursive_context_512_k_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>What is the default AUTOINDEX index and vector...</td>\n",
       "      <td>[True, and auto_id is enabled for the primary ...</td>\n",
       "      <td>The default AUTOINDEX index in Milvus is IVF_S...</td>\n",
       "      <td>Index type = HNSW and distance metric=IP Inner...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>recursive_context_512_k_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>What do the parameters for HNSW mean?</td>\n",
       "      <td>[layer, finds the node closest to the target i...</td>\n",
       "      <td>The parameters for HNSW (Hierarchical Navigabl...</td>\n",
       "      <td>* M: maximum degree, or number of connections ...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>html_context_512_k_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>What are good default values for HNSW paramete...</td>\n",
       "      <td>[you can set the top-K up to 8192 for any sear...</td>\n",
       "      <td>* M=48  * efConstruction=200</td>\n",
       "      <td>M=16, efConstruction=32,  ef=32</td>\n",
       "      <td>0.250000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.400000</td>\n",
       "      <td>html_context_512_k_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>What does nlist vs nprobe mean in ivf_flat?</td>\n",
       "      <td>[performance can be improved with minimal impa...</td>\n",
       "      <td>- nlist refers to the number of clusters into ...</td>\n",
       "      <td># nlist:  controls how the vector data is part...</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>html_context_512_k_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>What is the default AUTOINDEX index and vector...</td>\n",
       "      <td>[is set to True, and auto_id is enabled for th...</td>\n",
       "      <td>The default AUTOINDEX index in Milvus is IVF_S...</td>\n",
       "      <td>Index type = HNSW and distance metric=IP Inner...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>html_context_512_k_2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>What do the parameters for HNSW mean?</td>\n",
       "      <td>[Parameter Description Range Default value npr...</td>\n",
       "      <td>The parameters for HNSW (Hierarchical Navigabl...</td>\n",
       "      <td>* M: maximum degree, or number of connections ...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>parent_context_1536_k1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>What are good default values for HNSW paramete...</td>\n",
       "      <td>[Select your Milvus distribution first. Index ...</td>\n",
       "      <td>* M=48  * efConstruction=200</td>\n",
       "      <td>M=16, efConstruction=32,  ef=32</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>parent_context_1536_k1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>What does nlist vs nprobe mean in ivf_flat?</td>\n",
       "      <td>[FAQ What is the difference between FLAT index...</td>\n",
       "      <td>- nlist refers to the number of clusters into ...</td>\n",
       "      <td># nlist:  controls how the vector data is part...</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.800000</td>\n",
       "      <td>parent_context_1536_k1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>What is the default AUTOINDEX index and vector...</td>\n",
       "      <td>[vector in the data to be inserted, are treate...</td>\n",
       "      <td>The default AUTOINDEX index in Milvus is IVF_S...</td>\n",
       "      <td>Index type = HNSW and distance metric=IP Inner...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>parent_context_1536_k1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>What do the parameters for HNSW mean?</td>\n",
       "      <td>[Index building parameters Parameter Descripti...</td>\n",
       "      <td>The parameters for HNSW (Hierarchical Navigabl...</td>\n",
       "      <td>* M: maximum degree, or number of connections ...</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>semantic_context_k_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>What are good default values for HNSW paramete...</td>\n",
       "      <td>[Index building parameters Parameter Descripti...</td>\n",
       "      <td>* M=48  * efConstruction=200</td>\n",
       "      <td>M=16, efConstruction=32,  ef=32</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>semantic_context_k_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>What does nlist vs nprobe mean in ivf_flat?</td>\n",
       "      <td>[See Supported Metrics. IVF_FLAT IVF_FLAT divi...</td>\n",
       "      <td>- nlist refers to the number of clusters into ...</td>\n",
       "      <td># nlist:  controls how the vector data is part...</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>semantic_context_k_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>What is the default AUTOINDEX index and vector...</td>\n",
       "      <td>[For a detailed explanation of the schema, ref...</td>\n",
       "      <td>The default AUTOINDEX index in Milvus is IVF_S...</td>\n",
       "      <td>Index type = HNSW and distance metric=IP Inner...</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>semantic_context_k_1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>What do the parameters for HNSW mean?</td>\n",
       "      <td>[* `M`: The maximum number of outgoing connect...</td>\n",
       "      <td>The parameters for HNSW (Hierarchical Navigabl...</td>\n",
       "      <td>* M: maximum degree, or number of connections ...</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.800000</td>\n",
       "      <td>semantic_context_k_2_summary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>What are good default values for HNSW paramete...</td>\n",
       "      <td>[* `nlist`: This parameter controls the number...</td>\n",
       "      <td>* M=48  * efConstruction=200</td>\n",
       "      <td>M=16, efConstruction=32,  ef=32</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.333333</td>\n",
       "      <td>semantic_context_k_2_summary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>What does nlist vs nprobe mean in ivf_flat?</td>\n",
       "      <td>[**nlist (Number of List)**:\\nThis parameter d...</td>\n",
       "      <td>- nlist refers to the number of clusters into ...</td>\n",
       "      <td># nlist:  controls how the vector data is part...</td>\n",
       "      <td>0.750000</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.857143</td>\n",
       "      <td>semantic_context_k_2_summary</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>What is the default AUTOINDEX index and vector...</td>\n",
       "      <td>[According to the provided text, when creating...</td>\n",
       "      <td>The default AUTOINDEX index in Milvus is IVF_S...</td>\n",
       "      <td>Index type = HNSW and distance metric=IP Inner...</td>\n",
       "      <td>0.500000</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>semantic_context_k_2_summary</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             question  \\\n",
       "0               What do the parameters for HNSW mean?   \n",
       "1   What are good default values for HNSW paramete...   \n",
       "2         What does nlist vs nprobe mean in ivf_flat?   \n",
       "3   What is the default AUTOINDEX index and vector...   \n",
       "4               What do the parameters for HNSW mean?   \n",
       "5   What are good default values for HNSW paramete...   \n",
       "6         What does nlist vs nprobe mean in ivf_flat?   \n",
       "7   What is the default AUTOINDEX index and vector...   \n",
       "8               What do the parameters for HNSW mean?   \n",
       "9   What are good default values for HNSW paramete...   \n",
       "10        What does nlist vs nprobe mean in ivf_flat?   \n",
       "11  What is the default AUTOINDEX index and vector...   \n",
       "12              What do the parameters for HNSW mean?   \n",
       "13  What are good default values for HNSW paramete...   \n",
       "14        What does nlist vs nprobe mean in ivf_flat?   \n",
       "15  What is the default AUTOINDEX index and vector...   \n",
       "16              What do the parameters for HNSW mean?   \n",
       "17  What are good default values for HNSW paramete...   \n",
       "18        What does nlist vs nprobe mean in ivf_flat?   \n",
       "19  What is the default AUTOINDEX index and vector...   \n",
       "\n",
       "                                             contexts  \\\n",
       "0   [node closest to the target in this layer, and...   \n",
       "1   [Select your Milvus distribution first. Index ...   \n",
       "2   [FAQ What is the difference between FLAT index...   \n",
       "3   [True, and auto_id is enabled for the primary ...   \n",
       "4   [layer, finds the node closest to the target i...   \n",
       "5   [you can set the top-K up to 8192 for any sear...   \n",
       "6   [performance can be improved with minimal impa...   \n",
       "7   [is set to True, and auto_id is enabled for th...   \n",
       "8   [Parameter Description Range Default value npr...   \n",
       "9   [Select your Milvus distribution first. Index ...   \n",
       "10  [FAQ What is the difference between FLAT index...   \n",
       "11  [vector in the data to be inserted, are treate...   \n",
       "12  [Index building parameters Parameter Descripti...   \n",
       "13  [Index building parameters Parameter Descripti...   \n",
       "14  [See Supported Metrics. IVF_FLAT IVF_FLAT divi...   \n",
       "15  [For a detailed explanation of the schema, ref...   \n",
       "16  [* `M`: The maximum number of outgoing connect...   \n",
       "17  [* `nlist`: This parameter controls the number...   \n",
       "18  [**nlist (Number of List)**:\\nThis parameter d...   \n",
       "19  [According to the provided text, when creating...   \n",
       "\n",
       "                                               answer  \\\n",
       "0   The parameters for HNSW (Hierarchical Navigabl...   \n",
       "1                        * M=48 \n",
       "* efConstruction=200   \n",
       "2   - nlist refers to the number of clusters into ...   \n",
       "3   The default AUTOINDEX index in Milvus is IVF_S...   \n",
       "4   The parameters for HNSW (Hierarchical Navigabl...   \n",
       "5                        * M=48 \n",
       "* efConstruction=200   \n",
       "6   - nlist refers to the number of clusters into ...   \n",
       "7   The default AUTOINDEX index in Milvus is IVF_S...   \n",
       "8   The parameters for HNSW (Hierarchical Navigabl...   \n",
       "9                        * M=48 \n",
       "* efConstruction=200   \n",
       "10  - nlist refers to the number of clusters into ...   \n",
       "11  The default AUTOINDEX index in Milvus is IVF_S...   \n",
       "12  The parameters for HNSW (Hierarchical Navigabl...   \n",
       "13                       * M=48 \n",
       "* efConstruction=200   \n",
       "14  - nlist refers to the number of clusters into ...   \n",
       "15  The default AUTOINDEX index in Milvus is IVF_S...   \n",
       "16  The parameters for HNSW (Hierarchical Navigabl...   \n",
       "17                       * M=48 \n",
       "* efConstruction=200   \n",
       "18  - nlist refers to the number of clusters into ...   \n",
       "19  The default AUTOINDEX index in Milvus is IVF_S...   \n",
       "\n",
       "                                         ground_truth  context_recall  \\\n",
       "0   * M: maximum degree, or number of connections ...        1.000000   \n",
       "1                     M=16, efConstruction=32, \n",
       "ef=32        0.000000   \n",
       "2   # nlist:  controls how the vector data is part...        0.500000   \n",
       "3   Index type = HNSW and distance metric=IP Inner...        1.000000   \n",
       "4   * M: maximum degree, or number of connections ...        1.000000   \n",
       "5                     M=16, efConstruction=32, \n",
       "ef=32        0.250000   \n",
       "6   # nlist:  controls how the vector data is part...        0.500000   \n",
       "7   Index type = HNSW and distance metric=IP Inner...        1.000000   \n",
       "8   * M: maximum degree, or number of connections ...        1.000000   \n",
       "9                     M=16, efConstruction=32, \n",
       "ef=32        0.000000   \n",
       "10  # nlist:  controls how the vector data is part...        0.666667   \n",
       "11  Index type = HNSW and distance metric=IP Inner...        1.000000   \n",
       "12  * M: maximum degree, or number of connections ...        1.000000   \n",
       "13                    M=16, efConstruction=32, \n",
       "ef=32        0.333333   \n",
       "14  # nlist:  controls how the vector data is part...        0.000000   \n",
       "15  Index type = HNSW and distance metric=IP Inner...        0.333333   \n",
       "16  * M: maximum degree, or number of connections ...        0.666667   \n",
       "17                    M=16, efConstruction=32, \n",
       "ef=32        0.200000   \n",
       "18  # nlist:  controls how the vector data is part...        0.750000   \n",
       "19  Index type = HNSW and distance metric=IP Inner...        0.500000   \n",
       "\n",
       "    context_precision  context_f1                     evaluated  \n",
       "0                 1.0    1.000000     recursive_context_512_k_2  \n",
       "1                 1.0    0.000000     recursive_context_512_k_2  \n",
       "2                 1.0    0.666667     recursive_context_512_k_2  \n",
       "3                 1.0    1.000000     recursive_context_512_k_2  \n",
       "4                 1.0    1.000000          html_context_512_k_2  \n",
       "5                 1.0    0.400000          html_context_512_k_2  \n",
       "6                 1.0    0.666667          html_context_512_k_2  \n",
       "7                 1.0    1.000000          html_context_512_k_2  \n",
       "8                 1.0    1.000000        parent_context_1536_k1  \n",
       "9                 1.0    0.000000        parent_context_1536_k1  \n",
       "10                1.0    0.800000        parent_context_1536_k1  \n",
       "11                1.0    1.000000        parent_context_1536_k1  \n",
       "12                1.0    1.000000          semantic_context_k_1  \n",
       "13                1.0    0.500000          semantic_context_k_1  \n",
       "14                1.0    0.000000          semantic_context_k_1  \n",
       "15                0.0    0.000000          semantic_context_k_1  \n",
       "16                1.0    0.800000  semantic_context_k_2_summary  \n",
       "17                1.0    0.333333  semantic_context_k_2_summary  \n",
       "18                1.0    0.857143  semantic_context_k_2_summary  \n",
       "19                0.0    0.000000  semantic_context_k_2_summary  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate and print the percent improvements.\n",
    "if EVALUATE_WHAT == 'ANSWERS':\n",
    "    # Sort scores from highest to lowest\n",
    "    sorted_scores = sorted(scores, key=lambda item: sum(item.values()), reverse=True)\n",
    "    pprint.pprint(sorted_scores)\n",
    "    # Calculate the percent improvement of the best LLM over the worst LLM.\n",
    "    highest_score = list(sorted_scores[0].values())[0]\n",
    "    lowest_score = list(sorted_scores[-1].values())[0]\n",
    "    best_llm = list(sorted_scores[0].keys())[0]\n",
    "    worst_llm = list(sorted_scores[-1].keys())[0]\n",
    "    percent_better = (highest_score - lowest_score) / lowest_score * 100\n",
    "    print(f\"{best_llm} {np.round(percent_better,0)}% improvement over {worst_llm}.\")\n",
    "\n",
    "elif EVALUATE_WHAT == 'CONTEXTS':\n",
    "    pprint.pprint(scores)\n",
    "    percent_better = (scores[1]['html_context_512_k_2'] - scores[3]['semantic_context_k_1']) \\\n",
    "                     / scores[3]['semantic_context_k_1'] * 100\n",
    "    print(f\"Chunking {np.round(percent_better,0)}% improvement.\")\n",
    "\n",
    "# Display the evaluation details.\n",
    "display(ragas_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c408624",
   "metadata": {},
   "outputs": [],
   "source": [
    "########### CHANGE THE CHUNKING STRATEGY ###########\n",
    "# F1-Score 'html_context_512_k_2': 0.77  (108% improvement)\n",
    "# F1-Score 'parent_context_1536_k1': 0.7\n",
    "# F1-Score 'recursive_context_512_k_2': 0.67\n",
    "# F1-Score 'semantic_context_k_2_summary': 0.5\n",
    "# F1-Score 'semantic_context_k_1': 0.37\n",
    "####################################################\n",
    "\n",
    "########### CHANGE THE CHUNKING STRATEGY ###########\n",
    "# F1-Score 'parent_context_1536_k1': 0.7 (89% improvement)\n",
    "# F1-Score 'recursive_context_512_k_2': 0.67\n",
    "# F1-Score 'semantic_context_k_2_summary': 0.5\n",
    "# F1-Score 'semantic_context_k_1': 0.37\n",
    "####################################################\n",
    "\n",
    "\n",
    "########### CHANGE THE EMBEDDING MODEL #############\n",
    "# F1-Score 'parent_context_1536_k1_text-embedding-3-small': 0.84  (20% improvement)\n",
    "# F1-Score 'parent_context_1536_k1': 0.7\n",
    "####################################################\n",
    "\n",
    "############## CHANGE THE LLM ######################\n",
    "# Avg mistralai mixtral_8x7b_instruct score = 0.7031 (6% improvement)\n",
    "# Avg llama3_70b_anyscale_chat score = 0.6888\n",
    "# Avg llama3_70b_groq_instruct score = 0.6867\n",
    "# Avg llama_3_70b_octoai_instruct score = 0.6863\n",
    "# Avg llama_3_8b_ollama_instruct score = 0.6783\n",
    "# Avg openai gpt-3.5-turbo score = 0.665 \n",
    "####################################################\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "d0e81e68",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete the Milvus collection and doc store.\n",
    "del vectorstore, retriever, store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "c777937e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Author: Christy Bergman\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.11.8\n",
      "IPython version      : 8.22.2\n",
      "\n",
      "unstructured: 0.14.4\n",
      "lxml        : 5.1.0\n",
      "torch       : 2.3.0\n",
      "pymilvus    : 2.4.4\n",
      "langchain   : 0.2.6\n",
      "ollama      : 0.1.8\n",
      "octoai      : 1.0.2\n",
      "groq        : 0.8.0\n",
      "openai      : 1.35.0\n",
      "ragas       : 0.1.9\n",
      "\n",
      "conda environment: py311-unum\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Props to Sebastian Raschka for this handy watermark.\n",
    "# !pip install watermark\n",
    "%load_ext watermark\n",
    "\n",
    "%watermark -a 'Christy Bergman' -v -p unstructured,lxml,torch,pymilvus,langchain,ollama,octoai,groq,openai,ragas --conda"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
